witcheer's Wingtips for Hermes Agent

a project in Hermes Agent is a named workspace that can hold several folders, say an API repo and a WEB repo for one app.

in Hermes Desktop you can move a chat into one by asking:

switch this chat to my Recipe Box project

Hermes finds it by name and moves the chat's workspace to the project's primary folder. ask which projects you have and it lists them, with the one this chat is in.

nice when one chat turns into work on another app, or when you hop between a side project and the day job!

docs: https://hermes-agent.nousresearch.com/docs/reference/tools-reference

start the schedule with "in" and the job runs one time:

hermes cron create "in 2h" "Remind me to call the dentist before they close."

your gateway runs it once, two hours from now, and the job then clears itself from your list. "in 30m" and "in 1d" work the same way.

handy for a call to return, a parcel to chase or a build to check later today!

docs: https://hermes-agent.nousresearch.com/docs/user-guide/features/cron

Hermes Agent's local browser runs in the background by default. one setting opens it as a Chromium window on your screen:

hermes config set browser.headed true

you see every page and click as the agent works. the window also stays open between turns, so you can sign in or clear a CAPTCHA yourself, and your login stays warm across the conversation.

great for watching a new task run the first time, a site that asks you to sign in or a demo for a friend!

docs: https://hermes-agent.nousresearch.com/docs/user-guide/features/browser

when you and your agent finish a task you will do again, ask it to keep the steps as a skill:

save what we did as a skill called weekly-update

it writes the steps from the chat you had and saves them. the name you pick becomes a slash command, so in a new chat you type /weekly-update with your notes and it follows the same steps.

great for a weekly update, a report you format the same way every time or a setup you repeat on each new project!

docs: https://hermes-agent.nousresearch.com/docs/guides/tips#when-to-create-skills

the Hermes plugin catalog is a reviewed list of plugins you can install by name. you can search it from your terminal:

hermes plugins search <term>

type a word like weather, rss or telegram. Hermes matches it against plugin names, descriptions and the tools each plugin adds, and the results end with the install line. the install then asks if you want the plugin on straight away.

great when you want weather tools for your agent, an RSS reader in Hermes Desktop or a new memory provider!

docs: https://hermes-agent.nousresearch.com/docs/user-guide/features/plugins

Hermes Agent keeps its own memory in MEMORY.md and USER.md. a memory provider runs alongside it and adds things like semantic search, knowledge graphs and automatic fact extraction.

one command walks you through adding one:

hermes memory setup

pick a provider from the list, answer its setup questions and start a new session. your built-in memory stays on the whole time.

great for a long project, a research habit or an agent you talk to every day!

docs: https://hermes-agent.nousresearch.com/docs/user-guide/features/memory-providers

the skills hub reads skills through the GitHub API, and without a token GitHub allows 60 requests an hour per network address.

one line moves your Hermes Agent onto its own budget of 5,000 an hour:

hermes config set GITHUB_TOKEN <your token>

docs: https://hermes-agent.nousresearch.com/docs/user-guide/features/skills

by default, when your Hermes Agent's gateway starts, it skips the Telegram messages that arrived while it was off.

if your agent runs on a computer that sleeps or shuts down at night, set this once:

hermes config set platforms.telegram.extra.drop_pending_on_cold_boot false

on the next start, those messages come in, in order.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/messaging/telegram#cold-boot-pending-queue-optional

want your Hermes Agent to ask before it changes anything through an MCP server?

trust: untrusted

add it under that server in config.yaml. tools the server marks read-only run as normal, and every other tool waits for your /approve.

docs: https://hermes-agent.nousresearch.com/docs/reference/mcp-config-reference#server-keys

want to restart your Hermes Agent while you're away from your computer?

/restart

send it in the chat with your bot. it finishes the task it is working on, then restarts and messages you when it is back.

docs: https://hermes-agent.nousresearch.com/docs/reference/slash-commands#messaging-slash-commands

switching between the same few models with your Hermes Agent?

click the star next to a model in the Hermes Desktop model picker

it moves into a Favorites section at the top, wherever you pick a model in the app.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/desktop#choosing-a-model

working through something hard with your Hermes Agent?

/reasoning high

the model does more thinking before each answer, for the rest of this session.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/configuration#reasoning-effort

want your Hermes Agent to keep working after you close the window?

Settings > Appearance > Window layout > Minimize to tray

closing the main window then hides Hermes Desktop in the system tray, and your sessions keep running.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/desktop#minimize-to-tray

a source install of Hermes Agent now goes from one published release to the next when you update.

want every commit on main instead?

hermes update --set-channel main

on a source install, Hermes Desktop has the same switch: Settings > About > Updates > Update channel.

docs: https://hermes-agent.nousresearch.com/docs/getting-started/updating

want an answer from your Hermes Agent in an email or a doc?

/copy

it puts the agent's last answer on your clipboard, ready to paste. type it in the terminal chat, right after the answer you want.

handy when your agent drafts something you're about to send!

docs: https://hermes-agent.nousresearch.com/docs/reference/slash-commands

want your Hermes Agent to check the details with you?

"ask me a few questions first"

add that to your message. in the terminal, it can put its questions together in one panel, with choices to pick or room for your own answer.

docs: https://hermes-agent.nousresearch.com/docs/reference/tools-reference#clarify-toolset

is your Hermes Agent on a server in another timezone? give it yours:

hermes config set timezone America/New_York

the agent clock and your cron schedules follow that zone, so a job set for 8am runs at 8am where you are.

use your zone's IANA name, like Europe/London or Asia/Kolkata.

set it once, before your first morning brief or daily reminder!

docs: https://hermes-agent.nousresearch.com/docs/user-guide/configuration#timezone

sent something and want to ask it another way?

/undo

it removes your last message and the agent's reply from the chat. the agent carries on from the message before it, so you can ask again the way you meant.

handy when you change your mind halfway through a chat!

Hermes asks before it removes anything: approve this once, approve from now on, or cancel. /undo changes the chat, not your files; for files the agent changed, that's /rollback with checkpoints on (Wingtips #33).

docs: https://hermes-agent.nousresearch.com/docs/reference/slash-commands

your Hermes Agent can run the same prompt again every few minutes, inside the chat you're already in.

type /loop, how often, then what it should check:

/loop 5m check build.log and tell me when the build is done

handy while a build or a deploy is running!

docs: https://hermes-agent.nousresearch.com/docs/user-guide/features/loops

your Hermes Agent can take a whole file as part of your message, with no copy and paste.

type @, pick file: from the menu, then add the file's name and your question:

@file:meeting-notes.md turn this into a to-do list

handy for meeting notes, or a config file you want checked!

on X the line carries a space after the @ so it doesn't tag an account. type it with no space.

only part of a file? add the line numbers after the name: @file:meeting-notes.md:3-5 sends lines 3 to 5.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/features/context-references

your Hermes Agent can find a skill and run the install itself, so you don't need the skill's name or the command. ask in plain words:

"find a skill for flashcards and install it."

it picks a match, runs the security scan and then tells you what to say to use the new skill.

handy when you want your agent to pick up something new, or when you're setting up a fresh profile!

it knows how because every Hermes Agent ships with a built-in skill called hermes-agent, which covers how Hermes works and how to configure it.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/features/skills

on a fresh install, this one command logs your Hermes Agent in to Nous Portal and sets Nous as your provider. it turns on the Tool Gateway too:

hermes setup --portal

your browser opens for the login and you pick a model. then you're back in the terminal, ready to chat.

with any paid Nous Portal plan, that same login gives your agent web search, image generation, text-to-speech and a cloud browser, without one extra API key to set up!

to see what got switched on, run hermes portal info.

docs: https://hermes-agent.nousresearch.com/docs/integrations/nous-portal

your Hermes Agent can send you files on Telegram, not only text.

want something you can read later on your phone, or forward to someone?

ask for the format in your message:

"send me that as a PDF"

Hermes makes the file and it arrives in the chat as an attachment.

it works for a chart too, which comes through as an image, or a table as a spreadsheet!

want it every time? add a line to your ~/.hermes/SOUL.md asking for files over long text replies in chat.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/features/deliverable-mode

it sets up a ready-made automation for your Hermes Agent. Hermes asks you what it needs, one question at a time, then schedules it as a cron job. you do not write any cron syntax.

want a short lesson on a topic you pick, every weekday morning?

type this in the chat:

/blueprint learn-daily

other blueprints cover a reminder in your own words, or a weekly meal plan with the grocery list!

/blueprint on its own lists every blueprint your Hermes Agent has.

docs: https://hermes-agent.nousresearch.com/docs/reference/automation-blueprints-catalog

it copies your conversation with your Hermes Agent into a new session, history included, and you carry on in the copy.

want to try a different idea without losing where you are?

type this in the chat:

/branch

useful before a big change of direction, or to compare two answers from the same starting point!

name the branch if you like: /branch plan-b. without a name it takes the original title with a number.

docs: https://hermes-agent.nousresearch.com/docs/reference/slash-commands

your Hermes Agent's context window holds more than your messages: the system prompt, the tool definitions, your memory, any project rules and the conversation so far.

how much room does each one take?

type this in the chat:

/context

you get a breakdown of the window by what fills it, with the free space that is left.

useful before a long session, or when you want to see how close a chat is to compressing!

docs: https://hermes-agent.nousresearch.com/docs/reference/slash-commands

you are mid-conversation with your Hermes Agent in the terminal and you have to leave your desk.

type this in the chat:

/handoff telegram

the session moves to your Telegram home channel with its full history, and the agent replies there with a short summary of where you left off. you carry on from your phone.

useful when you head out mid-project, or when a chat you started at your desk needs finishing on the train!

docs: https://hermes-agent.nousresearch.com/docs/user-guide/sessions#cross-platform-handoff

one command sends a message from any script to the platforms your Hermes Agent is already set up on.

it uses your gateway's bot credentials and makes no model call.

hermes send --to telegram "deploy finished"

or pipe anything into it:

tail -n 20 build.log | hermes send --to telegram

useful in cron scripts, CI jobs, or as a ping when a long training run is done!

docs: https://hermes-agent.nousresearch.com/docs/guides/pipe-script-output

one command stops your Hermes Agent from starting new work. while it is on:

• no cron job fires
• no kanban task is dispatched
• your gateway bots start no new turns

hermes resume lifts it.

useful when a scheduled job does something you did not expect, or before you change a skill your cron jobs use!

docs: https://hermes-agent.nousresearch.com/docs/user-guide/features/cron#pausing-everything-hermes-pause

new in Hermes Agent: a cap on how many MCP servers connect at the same time.

the servers in your config connect when your Hermes Agent starts, and each local one runs as its own process.

raise it to bring a long list of servers up sooner, or lower it on a small machine.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/features/mcp#discovery-time

when the smart-approval reviewer denies a command, Hermes Agent can try a variation of it.

this key counts those denials in a row, per session. at 3, the deny message tells the agent to stop, report what was blocked, and ask you to run it yourself or /approve it.

lower it to stop sooner, or set 0 to turn it off.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/configuration#denial-circuit-breaker

if your Hermes bot has ever sent "Agent session appears stalled", that is a watchdog, and it never stops the turn.

it speaks up once when you have sent a follow-up and the agent has shown no activity for 5 minutes. then it is your call: /new, /stop, or keep waiting.

raise the number for long jobs, or set 0 to turn it off.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/configuration#session-stall-watchdog

when someone you have not approved messages your Hermes bot, it answers with a one-time pairing code, so you can let them in from the CLI.

new in Hermes Agent: if the bot is only for you, it can say no instead.

unauthorized_dm_behavior: decline

one short, polite decline, then silence toward that sender for a day.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/configuration#unauthorized-dm-behavior

Hermes Agent loads a skill when a task calls for it. some skills you want in every session whatever the task: a house style, a review checklist, the way you write commits.

new in Hermes Agent (v0.21.4 and newer): this key pins them. every name on the list is fully loaded at the start of every new session, on the CLI, on every gateway platform, in cron jobs.

skills:
  auto_load:
    - my-workflow
    - github-pr-workflow

resolved once, when the prompt is first built, so the prompt stays cache-stable. an edit to the skill shows up in the next session.

hermes -s <skill> does the same for one launch. per profile, empty by default.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/configuration#auto-loading-skills-every-session

Hermes Agent picks its tools per platform: the CLI, Telegram, Discord and the rest each keep their own list of toolsets, set in hermes tools.

this key is one list above all of them. a toolset named here is removed everywhere at once, on the CLI and on every gateway platform. it is applied after the per-platform lists.

agent:
  disabled_toolsets:
    - web
    - memory

web takes web_search and web_extract out of every session. memory removes the memory tools and also drops the memory guidance from the prompt.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/configuration#global-toolset-disable

when Hermes Agent wants to run a terminal command that looks risky, a second model reviews it first. it reads the command and answers with one word: approve, deny, or escalate, which means ask you.

this key lets you add your own rules to that reviewer's instructions.

"always escalate anything that modifies /etc." "approve docker compose restarts in ~/deploys, they are routine here."

your rules are read as instructions from you, never as part of the command it is judging.

approvals:
  smart_policy: |
    Always ESCALATE commands that modify anything under /etc.

empty by default. the reviewer itself is on by default (approvals.mode: smart).

docs: https://hermes-agent.nousresearch.com/docs/user-guide/configuration#smart-approvals

you give Hermes Agent a long task in the CLI and switch to something else. while you are away it either finishes, or it stops to ask you something, an approval, a clarifying question, a sudo password, and waits.

either way you find out when you come back and look.

these two keys tell you instead.

bell_on_complete rings the terminal bell when a turn finishes. bell_on_prompt rings it the moment a blocking prompt opens. both work over SSH, so a Hermes running on a server rings in the terminal on your desk. in Ghostty, iTerm2, Kitty and WezTerm the same keys also raise a desktop notification.

hermes config set display.bell_on_complete true hermes config set display.bell_on_prompt true

both are off by default and read at startup, so restart the CLI after setting them.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/configuration

the Hermes Agent CLI has an input box where you type your message to the agent. out of the box it uses the standard terminal editing keys.

if you type in vim all day, that box can use vi keys instead: Esc puts you in NORMAL mode, i takes you back to INSERT, and the status bar shows the mode you are in at its right edge.

set display.vim_mode: true in your config.yaml and restart the CLI.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/configuration

besides your chat, Hermes Agent makes small model calls of its own: the summary written when a long conversation is compacted, the name it gives a session, reading an image you paste, the check on whether a command needs your approval.

those calls run on your main model unless you gave them another one, at the provider's default thinking level.

but a session title does not need deep thinking.

each side task has its own reasoning_effort. set it to low or none for that task and the call comes back sooner and costs less, while your chat keeps the level you set for it.

# in ~/.hermes/config.yaml  (or: hermes config set auxiliary.<task>.reasoning_effort low)
auxiliary:
  compression:
    reasoning_effort: low
  title_generation:
    reasoning_effort: none
  vision:
    reasoning_effort: none

levels: none, minimal, low, medium, high, xhigh, max, ultra. not set by default (the provider's default level). same knob on approval, curator, triage_specifier, kanban_decomposer, goal_judge and the other side tasks; your chat keeps its own agent.reasoning_effort. MoA slots set depth in the preset, and a background review that stays on your main model ignores this key.

docs: https://hermes-agent.nousresearch.com/docs/user-guide/configuration#the-universal-config-pattern

on OpenRouter, one model name is served by several hosts, and OpenRouter picks the host for each request.

but what if one of those hosts is rate-limiting you today?

provider_routing in config.yaml lets you choose.

list a host under ignore and your requests for that model stop going there, even when it is the cheapest one. the other hosts keep serving as before.

on Nous Portal you can skip this step: the Portal picks the host for every model on your behalf, so there is nothing to set.

# in ~/.hermes/config.yaml (OpenRouter setups)
provider_routing:
  ignore:
    - "<provider slug>"   # the lowercase slug OpenRouter shows for that host

same key, other lists: only: (allow these hosts) and order: (try these first). read at startup, so restart hermes or the gateway after the edit. list values: edit config.yaml directly, not hermes config set. one model only? put the same lists under models: for that model id.

docs: provider routing

your agent reads your messages through Telegram or Discord, but it does not see when you sent them.

message_timestamps under gateway in config.yaml changes that.

with enabled: true, every message you send carries its send time in front, for the model only. the chat you read does not change and the transcripts on disk stay clean. the agent can tell this morning from last week, notice a long gap, and answer with the right day in mind.

your messages only. the agent's replies and the system prompt are untouched.

gateway:
  message_timestamps:
    enabled: true

or from the terminal: hermes config set gateway.message_timestamps.enabled true

docs: https://hermes-agent.nousresearch.com/docs/user-guide/messaging#message-timestamps-in-model-context

your agent writes itself a new skill after a good session, and it lands in the profile's own skills folder, on that machine, for that profile.

create_dir under skills in config.yaml moves that.

every skill the agent creates from then on is written to the folder you name, a shared repo or a folder every profile can see. the agent's own instructions follow the setting, so it knows where new skills go without being told each time.

skills you already have stay where they are and are edited in place.

# in ~/.hermes/config.yaml
skills:
  create_dir: /opt/brain/skills

# or from the terminal
hermes config set skills.create_dir /opt/brain/skills

the folder is created on the first write. skills under it still show in hermes skills list, skill_view and as /skill-name slash commands. ~ and ${VAR} expand, and a relative path resolves against your Hermes home. this is the write side of #70 skills.external_dirs, which is where Hermes also reads skills from; point both at the same shared folder and you have one place for everything.

docs: redirecting skill creation

hand this to your agent: "set skills.create_dir to a folder of my choice, then create a two-line test skill and tell me the path you wrote it to."

you call Hermes Agent from a script or a cron job with hermes -z: one prompt in, the final answer out, nothing else printed.

the next call can continue that same conversation. add --resume latest and the earlier turns come back with it, so a second prompt can build on the first answer. a session id or a session title works in place of latest.

it is the same agent, the same tools and the same skills as your normal chat, with the interactive layer stripped off.

hermes -z "summarise the open pull requests on this repo"

hermes -z "now list the three that touch the gateway" --resume latest

the prompt goes straight after -z; put --resume before -z or after the prompt. -z also reads stdin (hermes -z "summarise this" < notes.txt), and --usage-file report.json writes tokens, api calls and an estimated cost after the run. tool output stays out of the answer; hermes chat --oneshot -q "..." keeps it in the transcript.

docs: hermes -z, scripted one-shot

hand this to your agent: "write me a shell script that asks you three follow-up questions about this repo with hermes -z, each call resuming the previous one, and prints the three answers. show it before saving."

you keep your skills in one folder for every agent tool you use, or your team keeps them in a shared repo.

Hermes Agent can scan those folders too.

add external_dirs under skills in config.yaml and every skill it finds there joins the index, shows up in hermes skills list, and answers to its /skill-name slash command, the same as a skill you installed yourself.

if a skill with the same name lives in both places, your local copy wins.

skills:
  external_dirs:
    - /home/shared/team-skills
    - ${SKILLS_REPO}/skills

or from the terminal:

hermes config set skills.external_dirs '["/home/shared/team-skills"]'

paths take ~ and environment variables; a folder that does not exist is skipped. a writable external folder can be edited by the agent's skill_manage tool, so use filesystem permissions if the shared set must stay read-only.

docs: external skill directories

hand this to your agent: "list every folder on this machine that holds SKILL.md files outside ~/.hermes/skills and tell me which ones are worth adding to skills.external_dirs. change nothing."

Hermes Wingtips #69: tool_loop.guardrails

your agent opens a file, reads it, decides to start over, and reads the same file again.

Hermes Agent keeps count of that inside one turn. it watches for three patterns: the same call failing twice in a row, the same tool failing on new arguments, and a call that comes back with the same result while nothing has changed. when a count is reached it writes a warning into the tool result itself, so the model reads it on the next step and changes course.

in the CLI, the TUI and the Desktop app that is where it ends, because you are there to step in. gateway and cron runs go one step further and stop the turn, since nobody is watching. a stop ends the turn, not the session, and the agent tells you which pattern fired.

hermes config set tool_loop_guardrails.hard_stop_enabled true

docs: https://hermes-agent.nousresearch.com/docs/user-guide/configuration#tool-loop-guardrails

Hermes Wingtips #68: /skill-name

you installed a skill, told your agent to use it, and the replies still come back the same.

every installed skill is also a slash command. /humanizer rewrite this reply in my voice loads the skill for that turn and then runs your request with it. the bare name on its own loads it and the agent asks what you need.

several skills stack in one message: every leading /skill is loaded, the rest of the line is the instruction.

for the agent to pick a skill without being told, it reads a short index of every description. a description that opens with when to use the skill gets picked up. one that opens with background does not get that far.

/humanizer <your request>

Hermes Wingtips #67: hermes debug share

you want to ask about something Hermes Agent did, in Discord or in an issue. the first questions back are always the same: which version, which model, which provider, what do the logs say.

Hermes has one command that builds the whole report: version and OS, model and provider, the recent lines of the agent, gateway and desktop logs, and which API keys are set. the key values never appear, the report only says set or not set, and the logs are redacted before anything is uploaded.

hermes debug share

add --local to print it in your terminal and read it first, nothing leaves your machine. the plain command uploads to a paste service and hands you a link that expires on its own.

Nous support asks for a bundle? --nous sends the same report to private storage only the team can see.

Hermes Wingtips #66: sessions.auto_prune

every conversation you have with Hermes Agent is kept, so you can resume it or search it later. over time, a busy gateway or cron setup collects a lot of ended sessions that nobody will open again.

so what happens to them?

Hermes now tidies up for you: sessions that have ended and sat untouched for a long while are removed when Hermes starts, and the database gives the space back when there is enough to reclaim. anything open, pinned or mid-conversation stays put, and your recent history stays searchable.

if you would rather keep every session forever, it is one command:

hermes config set sessions.auto_prune false

and if you like the cleanup but want a wider window, sessions.retention_days.

Hermes Wingtips #65: hermes sessions import

if you have a conversation going in Claude Code or Codex CLI, you can carry it on in Hermes Agent.

say you spent an hour with another coding agent on a feature, and now you want Hermes to take the next step with all of that context. instead of explaining it again from scratch, you bring the conversation over.

hermes sessions import

it lists the sessions it finds on your machine, newest first. pick one and it becomes a Hermes session you can resume like any other.

what comes across is the conversation itself: your messages, the answers, and a short note wherever a tool ran. your other agent's files are only read, never changed.

this is different from hermes import-agent, which moves your setup (instructions, skills). this one moves the chat.

Hermes Wingtips #64: AGENTS.override.md

when you open Hermes Agent inside a project, it reads the project's AGENTS.md on every turn. that file is where a team keeps its rules: how the code is laid out, what to never touch, which commands to run.

but what if you want your own rules in that project?

maybe you prefer shorter answers, or you want the agent to always run the tests before it reports back. editing the shared AGENTS.md pushes your habits onto everyone else.

this file is the way round it. put an AGENTS.override.md next to the team's AGENTS.md and Hermes loads yours instead of theirs. the tracked file stays exactly as your teammates wrote it.

touch AGENTS.override.md

add it to .gitignore and it never leaves your machine. it works in any folder that has an AGENTS.md, including subfolders the agent walks into during a session.

Hermes Wingtips #63: compression.context_timeout_seconds

when a chat gets long, Hermes summarises the older messages to free up room. a separate model writes that summary in the background while your conversation keeps going.

but what if that summary model hangs? without a guard, your whole session would sit there waiting on it.

this setting is that guard. if the summary model goes quiet for 120 seconds, Hermes stops waiting: it tries one backup model, and if that fails too it skips the summary, keeps all your messages and tells you.

hermes config set compression.context_timeout_seconds <seconds>

the guard only counts silence. a model that is slow but still writing gets all the time it needs. raise the number if your summary model runs on slower hardware, or set 0 to switch the guard off.

Hermes Wingtips #62: cron.model

your scheduled jobs and your chat sessions do not have to share a model. without a cron setting, a new job runs on your global default, the same model you chat with, even when the task is a small daily digest.

two ways to route cron spend:

(1) hermes config set cron.model \<model\>

a fleet default: every job without its own pin runs on this model.

(2) hermes cron edit \<job_id\> --model \<model\> --provider \<provider\>

a per-job pin, for when one heavy scheduled analysis deserves the big model while the rest run cheap.

super useful if you run digests, watchers or reminder jobs 24/7: keep the flagship for conversations and let a smaller model do the routine rounds!

Hermes Wingtips #61: cron preflight

before a scheduled job runs, your Hermes Agent checks that the run can actually succeed: the provider key resolves, attached skills have what they need, delivery targets are reachable.

a job that fails the check is marked blocked_config and alerts you once. no model call happens, so it sits at zero cost until you fix it.

the next healthy run clears the state on its own.

Hermes Wingtips #60: /bg vs /btw

(1) /bg hands a prompt to a separate session:

your Hermes Agent works on it in the background while your conversation stays free, and the result comes back when it is done.

(2) /btw is for a side question about the conversation you are already in:

it answers from a snapshot, so the task that is currently running never stops.

they also both work on messaging platforms, not only in the terminal.

Hermes Wingtips #59: a rate limit doesn't have to stop your session

Hermes Agent can carry a fallback chain: backup provider:model pairs it switches to automatically when your main model hits a rate limit, a server error or an auth failure.

~ hermes fallback

opens the same picker as hermes model. add as many backups as you want, they are tried in order.

history, tool calls and context all carry over, the agent continues from where it stopped. and it's per turn, your next message starts back on your primary.

one last tips: pin a local model last and no provider outage can fully stop you!

Hermes Wingtips #58: real profile browsing

it shipped in Hermes Agent this week, and the same questions keep coming back. the two big ones:

(1) "so the agent can see all my browser logins?"

it never touches your real browser. it browses a separate copy that you can revoke and delete any time. you stay in control the whole time.

(2) "does it work fully local, with a local model?"

yes. with any backend and any model, fully local setups included.

with this new tool, your agent can easily book flights, check orders, pull invoices and way more!

Hermes Wingtips #57: delegate_task

if you keep wiring up multi-agent teams by hand: several profiles, shared folders, a coordinator that ends up doing all the work itself. the built-in delegate_task tool is that whole pattern in one command.

workers start with zero knowledge of your conversation. put everything they need in the brief itself (paths, constraints, what done looks like), and give the coordinator the briefs, not the workers' tools.

that's also the perfect command for running workers on a cheaper model.

great for parallel research, code review, comparing approaches, anything you would split across a team!

Hermes Wingtips #56: switching models from anywhere

hermes model opens an interactive picker, so it refuses to run through a pipe, a script, or another agent's terminal tool.

the fix is that you never needed the picker. in any chat, on any platform:

/model grok-4 --provider x-ai --global

--global persists it to config.yaml and switches the running session in the same move.

--once is the sibling: it switches for a single turn and restores the previous model afterward, even on an error.

Hermes Wingtips #55: chaining cron jobs

every cron job wakes up in a fresh session. a two-step pipeline, collect then summarize, can't see what step one produced.

context_from wires the connection. when you create the second job, point it at the first job's id, and the first job's latest output is prepended to the second job's prompt at fire time.

a job can also point at itself. continuity injects the job's own previous output.

you set all of this by asking your Hermes Agent in plain language, it manages its own cron table.

Hermes Wingtips #54: session, project, profile, bot

the four words everyone meets, and what each one holds:

(1) a session is one conversation. your Hermes Agent keeps many, and every surface can open them.

(2) a project is a workspace: the folders your agent works in, grouped under one name.

(3) a profile is a whole separate agent. its own config, memory, skills, and history.

(4) a bot is a profile with a name and an avatar in the Desktop app. same thing underneath, one click away.

two of these hold your work, two of them are agents.

Hermes Wingtips #53: SOUL.md, AGENTS.md, MEMORY.md, USER.md

four markdown files shape your Hermes Agent. what each one does:

(1) SOUL.md is who your agent is: personality, tone, how it speaks. it exists so your agent stays the same agent everywhere, in every project and on every channel. it lives in ~/.hermes/.

(2) AGENTS.md is how one project works: structure, conventions, the commands that matter. it exists so project rules stay with the project instead of following your agent around. it lives in the project folder, loads only when your agent works there, and you write one per project.

(3) MEMORY.md is what your agent has learned by itself: environment facts, conventions it picked up, lessons from past work. it exists so your agent stops rediscovering the same things every session. your agent writes and maintains it, not you.

(4) USER.md is who you are to your agent: your preferences, your style, how you like your answers. it exists so you never have to introduce yourself twice. your agent maintains this one too.

the rule of thumb: everywhere means SOUL.md, one project means AGENTS.md, and the memory pair takes care of itself.

Hermes Wingtips #52: idle compaction

a long-lived thread carries its whole history back into context every time you come back to it, and you pay for that stale backlog on every turn.

your Hermes Agent has a time-based trigger for exactly this:

hermes config set compression.idle_compact_after_seconds 1800

the size-based threshold waits for the context to grow big. this one fires on the time gap since your last message. set it in seconds, 1800 = 30 minutes.

super useful if you keep one long Telegram or Discord thread with your agent, or park a session overnight and pick it up in the morning!

Hermes Wingtips #51: checkpoints in one-shot runs

your Hermes Agent snapshots files before it changes them, and that safety net is not limited to interactive sessions. a scripted run gets it too:

(1) hermes chat --checkpoints -q "your task"

the run snapshots each working directory before its first file change, exactly like a live session would. next time you open a session in that folder, /rollback lists those snapshots and can restore from them.

(2) hermes checkpoints status

shows every project the store knows about, with sizes and last touch, from any shell.

Hermes Wingtips #50: the [SILENT] marker

a monitoring job that reports every run trains you to ignore it. your Hermes Agent has a quieter contract: if a cron job's response contains [SILENT], delivery is suppressed and nothing lands in your chat.

the lever is the prompt itself:

"check if nginx is running. if everything is healthy, respond with only [SILENT]. otherwise, report the issue."

great for any check that should only speak up when something is wrong: uptime, disk space, backups, feed watchers!

Hermes Wingtips #49: compaction thresholds

when your Hermes Agent stops mid-task to summarize, the number in that warning is not random. compaction fires at a fixed fraction of your main model's context window.

the fraction is compression.threshold in config.yaml, and it is always read off the model you chat with, never the summarizers' window.

on smaller context windows Hermes waits longer by default, so a compaction cannot fire with half the window still free.

and if you switch between a huge-context model and a small one, compression.model_thresholds sets a different trigger per model, matched on the model name.

Hermes Wingtips #48: platform toolsets

your agent pays a fixed token overhead before it reads a single word of your message, and one of the biggest slice is not the prompt.

every tool your platform loads ships its full schema with every call, used or not.

if a session never touches the browser, image gen or TTS, platform_toolsets in config.yaml hands that platform a smaller set.

hermes prompt-size shows you the before and after without spending a token.

Hermes Wingtips #47: cron prompts

your agent nails a task in chat, you schedule the same thing with /cron, and the scheduled runs come back wrong.

the reason is simple: a cron job runs in a fresh session, with none of the chat context that made the task work. a prompt leaning on what you discussed earlier has nothing to lean on at run time.

so write the prompt like the agent has never met you: every url, every command, every rule spelled out inside the prompt itself.

this is also why a scheduled job cannot ask you clarifying questions, it answers with what the prompt gave it!

Hermes Wingtips #46: Browser Use

Browser Use mode is a browser harness from the Browser Use team: instead of driving the page one tool call per click, your agent writes one script that runs the whole flow.

since v2026.8.13 it is on by default. update, and web tasks get cheaper without touching a single config key.

Hermes Wingtips #45: if you ever want to bring an existing OpenClaw setup into Hermes Agent, there is a command for that.

hermes claw migrate imports your settings, memories and skills. you can add --dry-run and it only shows you the plan, nothing is touched.

worth knowing:

(1) API keys and tokens stay behind unless you explicitly pass --migrate-secrets

(2) before anything is applied a restore-point zip of your Hermes home is written, so the move itself is undoable.

Hermes Wingtips #44: your skills library has an undo button.

the curator is a background pass that tidies the skills your agent creates for itself: stale ones get archived, overlapping ones get merged.

worried it might archive a skill you cared about? it snapshots your whole skills folder before every pass, automatically.

hermes curator rollback --list shows every snapshot.

hermes curator rollback restores the newest one, and even the rollback takes a snapshot first, so you cannot lose anything trying.

Hermes Wingtips #43: Telegram topics or a second agent?

running several projects through one Telegram bot? there are two ways to split them, and they are not the same thing.

(1) /topic

parallel conversations inside one bot DM. still one agent behind them, so what it learns on one project helps the others.

(2) hermes profile create \<name\>

a second agent entirely, with its own bot.

pick topics when your projects should feed one brain, profiles when you need real walls between them. and both can run on the same machine!

Hermes Wingtips #42: the compaction-summary model

every time your context compacts, a model reads the whole transcript and writes the summary. by default that model is your main chat model.

if you run a frontier model, you are paying frontier price for housekeeping, and the pause you feel at every compaction is frontier latency too.

you can move that job to a fast, cheap model. below, the switch on my own agent:

Hermes Wingtips #41: approvals suggest

approving the same command for the third time this week? your Hermes Agent already keeps that history.

hermes approvals suggest mines your past approvals and turns the recurring ones into an allowlist proposal, so the prompts you always say yes to stop coming back.

it proposes, you pick, nothing is written on its own.

below, a real run on my own agent this morning.

Hermes Wingtips #40: give your local agent two commands, not root

when I'm running benchmarks, my local Hermes Agent stops and starts the model server on its own, from cron, with no password. it still cannot touch anything else as root.

the trick is a sudoers rule scoped to exactly one service: NOPASSWD applies to systemctl start and stop for that unit, nothing more.

still test the fence from the outside: sudo -n on any other service should still ask for a password.

Hermes Wingtips #39: the missing provider prefix

if a model id ever answers you with a 404 error, check the id before you check your keys.

providers know their models as vendor/model, and an id that lost its prefix (nemotron-3-ultra-550b-a55b instead of nvidia/nemotron-3-ultra-550b-a55b) returns a 404, so it reads like an outage.

a fix just merged for the next release: the error now names the model and suggests the prefixed id.

until then, the habit to keep in mind: vendor/model, always, and hermes model picks it correctly for you.

Hermes Wingtips #38: hermes doctor

your Hermes Agent ships with its own health check. one command reads your whole setup and prints a pass/fail report:

• security advisories and a MCP server audit
• python environment and version consistency
• config files, deprecated keys and

Hermes Wingtips #37: hermes project

real work rarely fits in one folder: an api repo, a web repo, an infra repo, all one product. a project gives that group one name.

(1) hermes project create "My App" ~/code/api ~/code/web creates one

(2) hermes project add-folder grows it

(3) hermes project use sets it as active

what is super cool is that the Desktop app groups your sessions by project automatically, and binding a kanban board with bind-board gives every task a deterministic worktree and branch convention.

Hermes Wingtips #36: hermes import-agent

if you already run Claude Code or Codex CLI, your setup can move over to Hermes Agent in one command:

hermes import-agent

it auto-detects ~/.claude or ~/.codex and maps everything to its Hermes equivalent:

global instructions become memories, skills come across as skills, MCP servers goes in your config, and Claude's permission rules become the command allowlist. API keys and credentials are never touched.

it always shows you the full plan before writing anything, and --dry-run previews without touching disk at all.

there is no need rebuilding the setup you already tuned!

Hermes Wingtips #35: hermes bundles

if you keep loading the same skills together for the same kind of job, group them under one command:

hermes bundles create <name> --skill <a> --skill <b>

typing /<name> in the CLI or any chat platform then loads every skill in the bundle at once.

a bundle is a tiny yaml file under ~/.hermes/skill-bundles/, so you can check it into a dotfiles repo and share a whole task profile with your team.

super cool for recurring jobs and tasks you perform every day, see below for a quick example :)

Hermes Wingtips #34: hermes proxy

your Nous Portal subscription can serve any other app that speaks the OpenAI API.

hermes proxy start runs a small local pass-through server. point the app at the address it prints, give it any placeholder API key and a model from your plan, and it will works.

in order to double check that the Portal login is ready, type hermes proxy status.

it serves the raw model, not your agent: if you want the whole agent (tools, memory, skills) behind an API, that is hermes serve.

this tips is for people using Open WebUI, Karakeep, or anything self-hosted that asks for an OpenAI key you did not want to buy!

Hermes Wingtips #33: checkpoints

checkpoints snapshot your project before Hermes Agent writes, patches or runs a destructive command, and /rollback puts things back.

(1) hermes chat --checkpoints

you can turns them on for one session, or keep them on with checkpoints: enabled: true in config.yaml.

(2) /rollback

lists every snapshot; /rollback diff <N> previews the change and /rollback <N> <file> restores a single file. everything lives under ~/.hermes/checkpoints/.

turning this on is great before a big refactor, before letting an agent loose on an unfamiliar repo, or before trying yolo mode!

as an example, here is a live recovery on my own box:

Hermes Wingtips #32: hermes insights

this command reads your local session database and prints the last 30 days:

• input and output tokens
• which models did the work
• which platforms your sessions came from
• your top tools by call count...

--days moves the window and --source narrows to one platform.

this is a useful command when you are deciding which model to demote, or when you just want to know which tool your agent leans on most!

as an example, here is one of my Hermes Agent:

Hermes Wingtips #31: see what every message costs before you send it

hermes prompt-size

it prints the fixed budget of a fresh session: the full system prompt, the skills index, your MEMORY.md and USER.md snapshots, the prompt tiers, and the JSON schemas for every enabled tool.

if you want to manage it:

• hermes tools turns off toolsets you never use
• hermes skills uninstalls what you don't need
• AGENTS.md in your working directory count towards the total too

Hermes Wingtips #30: back up your agent before you need to

(1) hermes backup

it writes ~/hermes-backup-<timestamp>.zip with config.yaml, .env, auth, memories, skills, sessions, cron and profiles. it copies the databases through SQLite's own backup API, so you can run it while Hermes is live.

(2) hermes import ~/hermes-backup-<timestamp>.zip puts it all back.

for a fast one, you can use hermes backup --quick, which targets critical state only: config.yaml, state.db, .env, auth and cron jobs.

hermes backup is super useful if you are moving to a new box, if you want to duplicate your agent or before doing any experiment!

Hermes Wingtips #29: local models context floor

you point Hermes Agent at Ollama, the first few turns are fine, then the agent starts forgetting instructions or repeating work.

the usual cause is that Ollama's default context depends on your VRAM, and under 24 GB it is 4,096 tokens. Hermes needs at least 64,000 for agent work, because the system prompt and tool schemas alone take 4k to 8k, and most servers drop your oldest messages once the window fills.

here is what to do server-side:

(1) Ollama: OLLAMA_CONTEXT_LENGTH=64000 ollama serve, then check the CONTEXT column in ollama ps

(2) vLLM: --max-model-len 64000

(3) llama.cpp: llama-server -m model.gguf -c 64000

LM Studio users can skip this since Hermes asks it to load the model at 64K by default.

Hermes Wingtips #28: cron jobs & workdir

a cron job runs in a completely fresh session, detached from any repo: no AGENTS.md is loaded, and the terminal and file tools start from wherever the gateway happens to be running.

the fix is one flag:

(1) hermes cron create "every 1d at 09:00" "audit open PRs, summarise CI health" --workdir /home/me/projects/acme

(2) or from the chat directly, just tell Hermes which directory the job should run in (the cronjob tool takes workdir= the same way)

with workdir set, the job loads AGENTS.md from that directory and every file tool runs inside it. the path must be absolute and exist, or the create is rejected.

Hermes Wingtips #27: /background

you do not have to wait while your agent grinds through a long task.

/background <prompt> spawns a completely separate agent session that runs in parallel: your chat stays fully interactive, and the result comes back as a panel in your terminal when it finishes.

(1) as an example: /background analyse the logs in /var/log and summarise today's errors.

you can run several at once, and the status bar shows how many are in flight.

(2) one thing to know: the background agent starts clean, with no knowledge of your conversation.

it only gets the prompt you give it, so write it self-contained. it inherits your model, provider and toolsets, so no setup needed.

Hermes Wingtips #26: every web page your agent reads costs a main-model call

web_extract is the tool Hermes agent uses to read web pages. by default the summariser that processes long pages reuses your main chat model.

it means that on every docs page, article, thread... the agent opens burns a full-price call to whatever model you're chatting with.

(1) route the summariser to a cheap model:

auxiliary:
  web_extract:
    provider: nous
    model: google/gemini-3-flash-preview

or pick it interactively: hermes model → configure auxiliary models → web_extract.

(2) if you need raw unsummarised content later, use browser_navigate & browser_snapshot instead.

the browser tool returns a live page without auxiliary-model rewriting.

Hermes Wingtips #25: /goal

/goal keeps working until a judge model calls it done, so a vague goal gets a vague judging. fix it by telling the judge what done means:

(1) let Hermes write it:

exemple: /goal draft migrate the auth service to JWT

(2) or spell it inline under

Hermes Wingtips #24: gateway sessions do not auto-reset by default.

the default is session_reset: mode: none, so a Telegram or Discord chat keeps its history across restarts until you say otherwise. if you want a clean slate on a schedule, opt in:

(1) idle resets after idle_minutes of quiet (default 1440, so 24h)

(2) daily resets once a day at at_hour (default 4, local time)

(3) both resets on whichever comes first

before any auto-reset it saves memories and skills first.

Hermes Wingtips #23: pointed Hermes at your own model and it prints the tool call instead of running it?

if the reply comes back as raw json like {"name": "web_search", ...}, your inference server handed the tool call over as text and Hermes never got to run it.

tool calling has to be switched on at the server, and it is off until you set it:

(1) vLLM: add --enable-auto-tool-choice --tool-call-parser hermes

(2) SGLang: add --tool-call-parser qwen (or your model's parser)

(3) llama.cpp: add --jinja

Hermes Wingtips #22: steer a task without stopping it

a lot of people think you have to stop the agent and start over to change direction mid-task. you don't. there is /steer.

while it works, send a mid-run note:

/steer focus on the auth module first

it arrives after the current tool call finishes, so nothing gets interrupted and it is not a new turn, just fresh direction the agent picks up as it goes.

two siblings worth knowing:

(1) /queue (alias /q) holds a prompt for the next turn without touching the current one

(2) /busy lets you set what plain Enter does while it works: queue, steer, or interrupt.

Hermes Wingtips #21: credential pools

a credential pool is several keys or logins for one provider. Hermes picks a healthy key, and when that key is rate-limited or out of quota it rotates to the next one.

(this is different from fallback providers. a fallback jumps to a different provider, and only after every key in the pool is exhausted).

(1) add a second key (OpenRouter example):

hermes auth add openrouter --api-key sk-or-...-key

(2) check the pool: hermes auth list

when Hermes does rotate, the new key has no cached prefix for your chat, so the next request re-reads the full history.

lastly, if you are on Nous Portal with a single OAuth login, you usually do not need a pool. this tip is for multi-key API setups.

Hermes Wingtips #20: how to use export

Hermes sessions export is one command for every format. pick with --format:

(1) md or qmd for a readable archive (one file per session and a manifest under ~/.hermes/session-exports)

(2) html for a self-contained page you can open and share

add --redact when anything leaves the box: it hides API keys, tokens and credentials from the write.

for one particular session: --session-id <id>.

Hermes Wingtips #19: it remembered, it just can't see it yet.

we snapshot MEMORY.md and USER.md once at session start so the LLM prefix cache stays warm.

a mid-session save hits disk immediately, and only lands in the system prompt on the next session.

you need the new fact in play now?

(1) start a fresh session (2) or hermes -c on the next turn

tool responses already show the live write.

Hermes Wingtips #18: keep auto-learning, review the writes

if you want Hermes to keep learning without changing memory or skills unchecked, turn on both approval gates:

~ /memory approval on ~ /skills approval on

new writes wait for your yes instead of landing immediately.

Hermes Wingtips #17: check the built-in tools before you install a skill

a lot of popular third-party skills overlap with what Hermes ships by default.

five that people overlook: memory, web search, browser control, cron, and sub-agents.

all are native tools with no install :)

Hermes Wingtips #16: gateway won't restart after a reboot? enable lingering

a user-service gateway runs under your login, so it stops at logout and won't come back after a reboot until you enable lingering.

headless VPS, zero root per restart:

hermes gateway install
sudo loginctl enable-linger $USER

or go boot-level: sudo hermes gateway install --system

Hermes Wingtips #15: a compaction rewrites your history into a working brief

when a long session reaches the compaction point, Hermes doesn't drop the middle turns, it rewrites them into a structured brief with fixed slots:

goal / constraints / progress / key decisions / relevant files / next steps / critical context.

that brief carries the working state forward, and the raw turns stay in state.db where session_search can still reach them.

so a compaction is your agent re-reading its own notes, not losing the thread.

(1) work in the brief's shape: state goals and decisions in plain words, so they map straight into the slots that get kept

(2) for anything that must never drop, put it in MEMORY.md, which reloads on every session no matter how many compactions happen

Hermes Wingtips #14: switching models resets your prompt cache

switch models mid-conversation and the next turn re-reads the whole thing at full input price. the cache key includes the model, so a new model means a cold cache. occasional switches are fine, frequent ones in a long session multiply your cost.

• batch your switches instead of ping-ponging mid-thread

• on a long session, start a fresh one or delegate (subagents get their own context) rather than switching back and forth

Hermes Wingtips #13: keep your Hermes session db lean

your Hermes agent keeps every session in one SQLite db at ~/.hermes/state.db, and we ship auto-prune off by default, so none of your history disappears: it all stays searchable.

we keep it lean: hundreds of sessions sit in

Hermes Wingtips #12: kanban's default worker workspace is scratch

you're handing a kanban task to a Hermes agent and want to keep the files it writes? one thing to know before you run it.

by default each kanban worker runs in a scratch workspace, and Hermes clears that workspace the moment the task completes. indeed, throwaway chores should not leave directories behind.

to keep the output, give the task its own workspace when you create it:

hermes kanban create "your task" --workspace dir:/absolute/path

two things to get right:

(1) name the workspace with dir: for anything you want to survive the run. no flag means scratch, cleared on completion.

(2) make the path absolute. Hermes accepts a relative path at create with no error, then rejects it when the worker spawns.

Hermes Wingtips #11: toolsets: all doesn't include the kanban tools

you want a Hermes agent to manage your kanban board for you, creating and moving tasks itself? it needs the kanban tools.

here is what you need to understand:

you give that agent's profile toolsets: [all] in ~/.hermes/config.yaml, figuring "all" covers everything, and the agent still turns up with no kanban tools at all.

the reason is that the kanban toolset is opt-in. all loads the everyday tools, but a few specialist ones (kanban is one) are left out on purpose, so a normal chat is not cluttered with board commands it will never use. you have to ask for kanban by name.

the fix is to add it to that profile's toolsets, spelled out:

toolsets:
- kanban

you need to do this only when you set up an agent to drive the board. the workers the board spawns on its own to run a task already get the tools automatically. this is just for the driver.

Hermes Wingtips #10: every fallback entry needs both provider and model

your fallback_providers list in ~/.hermes/config.yaml counts an entry as a real fallback only when it carries a provider field and a model field.

two things worth setting:

(1) write provider and model on every entry in the chain, top to bottom.

(2) put a local model last as your floor for a cloud outage, pointing provider: custom at your own llama.cpp or vLLM endpoint.

Hermes Wingtips #9: a profile is a whole separate agent, not a setting

a Hermes profile is a second agent in its own right: its own memory, sessions, skills and bot token. spin one up and it knows nothing your main agent does.

two things to understand:

(1) you want one agent across Telegram, Discord and WhatsApp? that's a single profile with several gateways: they share one SOUL.md and one memory, so it behaves as one agent everywhere.

vice versa, a profile per platform splits it into strangers.

(2) you want a fresh agent that starts from your current one? hermes profile create new --clone-all. without it the new profile is blank.

Hermes Wingtips #8: MoA

the new Mixture of Agents virtual model fans every turn out to four reference models plus an aggregator.

I put it on a fresh Hermes box: gpt-5.5, deepseek-v4-pro and sonnet-4.6 as references, opus-4.8 as the aggregator.

measured on the box:

• a single opus call ran 27.9k tokens for ~$0.14
• the full MoA turn ran 28.6k tokens for ~$0.15, the same within a cent

the system prompt and tool schemas dominate that number, and the references run on stripped context, so the four extra calls stay cheap. for one question, you get the whole ensemble for barely more than a single model.

and the quality is the point: Nous's HermesBench puts an opus + gpt-5.5 MoA at 0.8202 vs 0.7607 / 0.7412 for those models alone.

it is 5 calls a turn, so it scales with task length, which is exactly why Nous frames it for "genuinely difficult problems" and on that ground it's one of the better-value things they've shipped.

Hermes Wingtips #7

Hermes Agent drives your Mac in the background now, clicking and typing while your real cursor never moves.

simple setup:

• hermes computer-use install
• grant Screen Recording & Accessibility to CuaDriver
• then hermes -t computer_use chat.

any destructive actions wait for approval, we're keeping it safe.

Hermes Wingtips #6: if your Hermes box fills its disk, it's likely not the logs.

the unbounded growers are state-snapshots (750MB on mine), per-run cron output (1,500+ files), and stdout if your host pipes it to a file.

run the disk-cleanup plugin and watch those three before the "no space left" crash.

Hermes Wingtips #5: /learn

it turns a source into a reusable skill in one command.

four ways to feed it: a local code/docs folder, a doc url, a workflow you just ran, or pasted notes. reach for it once you've done something non-trivial and don't want to re-explain it next time.

the skill lands in ~/.hermes/skills/ and auto-loads only when a task calls for it, so it's procedural memory that doesn't bloat every prompt.

I used it today and it drafted a genuinely good skill, even pulling in a real adjacent feature I hadn't mentioned.

what you need to know: it currently ignores its own <=60-char description rule (mine came out 123 and 202 chars). 

since a skill's description loads every session, a 200-char one is dead weight. open the SKILL.md, tighten it, fix the author, before you rely on it or share it.

Hermes Wingtips #4: which file is your agent's brain

~ SOUL.md is who the agent is: slot #1 in the system prompt, it replaces the default identity.

~ USER.md is who you are.

~ MEMORY.md is the facts it keeps about your work.

~ AGENTS.md is your project's rules, found by walking the directory.

what you need to understand is that project rule files are first-match-wins. 
Hermes loads only one of .hermes.md, AGENTS.md, CLAUDE.md, .cursorrules, in that order. 

a .hermes.md in the repo shadows your AGENTS.md with no warning, and the rules you wrote never load.

SOUL.md is exempt, it always loads on its own from ~/.hermes/SOUL.md. 

if Hermes is ignoring your project instructions, check for a higher-priority file next to them. and it caps every one of these at 20,000 characters, then truncates the rest.

Hermes Wingtips #3: your agent didn't forget, its memory is a frozen snapshot.

tell it something, it saves to MEMORY.md, the write hits disk right away. but the curated memory block in the system prompt loads once at session start and stays fixed for the whole session.

this is on purpose, to keep the prefix cache warm.

so mid-session it can act like it "forgot" what it just saved. it didn't: tool calls still read the live on-disk value, only the injected block is frozen. it refreshes next session.

if you need it acting on a fresh memory right now, start a new session. the save already landed, it just shows up next time.

Hermes Wingtips #2

the 🗜️ icon, what context compression keeps and what it drops

this little emojy is the compression count: how many times Hermes auto-summarised the session to stay under the context limit, which kicks in around 50% full.

when compression occurs, it keeps your first 3 turns and your last 20, and summarises everything in between. a detail from the middle of a long session can then drop out, and the agent repeats work it already did, even though the opening goal and the recent turns are intact.

three levers when it bites, all in config.yaml, hot-reloading on a running gateway: 

- protect_last_n keeps more recent turns uncompressed 

- auxiliary.compression.model points the summariser at a cheap fast model so it does not burn main-model tokens

- model.context_length raises the ceiling so it fires later.

https://hermes-agent.nousresearch.com/docs/developer-guide/context-compression-and-caching

Hermes Wingtips #1

running a hermes agent in a telegram group and it just sits there silent? the usual cause is BotFather's group privacy mode: it's on by default, so the bot only sees messages that mention it or start with /.

plain group messages never reach it.

easy fix: message BotFather, /setprivacy, pick the bot, Disable.

it doesn't apply to groups the bot is already in. remove it from the group and re-add it for the change to take.

back from NousCon with a few "I'll send you that on Monday" promises? tell your Hermes Agent who you met and what you promised, and it sets one reminder for each.

the people stay in its memory, so you can ask it later who someone was.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Help me follow up after an event: keep
the people I met in memory and set one reminder for each thing
I promised them. Ask, do not assume.
</role>

<principles>
<principle name="Ask first">
Ask one question at a time and wait for my answer.
If you cannot get my answer, end your turn and create nothing.
</principle>
<principle name="Show me first">
Show me each person you would remember and every reminder you
would create, with its day and time, before you do either.
</principle>
<principle name="Only what I said">
Remember only what I tell you about each person.
Make one reminder per promise. Nothing else changes:
no files, no config.
</principle>
</principles>

<instructions>
1. Ask who I met. For each person, ask for a name, what they
   work on and one thing we talked about. Ask for another
   person until I say that is everyone.
2. For each person, ask what I promised them and by when.
3. Ask what time of day to remind me and where to send it.
4. Check each reminder's weekday and date on this computer.
   Show me each person and each reminder, naming the person,
   my promise and what we talked about. Then stop and wait
   for my yes.
5. After my yes, save the people to memory and create each
   reminder. Show me each next run.
</instructions>

<task>
Start with step one now.
</task>

you always forget to wish birthdays to your family and friends? your Hermes Agent can send you a gift idea and a line to text them a few days before, for each person you tell it about.

it asks for a name, a date and one thing they like, shows you the first heads-up, then sets one job per birthday.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Set up birthday heads-ups for the
people I want to remember. Ask, do not assume.
</role>

<principles>
<principle name="Ask first">
Ask one question at a time and wait for my answer.
If you cannot get my answer, end your turn and create nothing.
</principle>
<principle name="Show me first">
Write the heads-up for the nearest birthday before you plan
anything. Then show me every job you would create.
</principle>
<principle name="Quiet otherwise">
Send one heads-up per birthday. On every other day, send
nothing. Only the jobs are created: no files, no memory.
</principle>
</principles>

<instructions>
1. Ask for a name, a birthday and one thing that person likes.
   Ask for another person until I say that is everyone.
2. Ask how many days ahead I want the heads-up and where
   to send it.
3. Write the heads-up for the nearest birthday: a gift idea
   built from what that person likes, plus a one-line
   message I could send them.
4. Show me each scheduled job you would create. Then stop
   and wait for my yes.
5. After my yes, create each job. Show me each next run.
</instructions>

<task>
Start with step one now.
</task>

love r/houseplants but don't have time to scroll it every day? your Hermes Agent can send you the five posts worth reading once a week, one line and a link each.

it reads the place you follow, shows you a sample, then schedules a weekly digest that skips anything it already sent.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Set up one weekly digest for me
from a subreddit, forum or site I follow.
Ask, do not assume.
</role>

<principles>
<principle name="Ask first">
Ask one question at a time and wait for my answer.
If you cannot get my answer, end your turn and create nothing.
</principle>
<principle name="Show me first">
Read the source once before you plan anything.
Show me what this week's digest would look like.
</principle>
<principle name="Short and linked">
Five items at most, one line each, a link on every line.
Skip anything I have already seen in last week's digest.
</principle>
</principles>

<instructions>
1. Ask what I follow. A link is best.
2. Ask what I care about there and what I want to skip.
3. Read it once. Show me a sample digest for this week.
4. Ask which day and time to send it, and where.
5. Show me the scheduled job you would create. Then stop.
6. After my yes, create it. Show me the job and its next run.
</instructions>

<task>
Start with step one now.
</task>

forget to water the plants or take the bins out? your Hermes Agent can remind you, and keep reminding you until you've done it.

it asks what, when and where, then schedules a reminder that repeats until you reply.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Set up one reminder for me
that keeps coming back until I tell you it is done.
Ask, do not assume.
</role>

<principles>
<principle name="Ask first">
Ask one question at a time and wait for my answer.
If you cannot get my answer, end your turn and create nothing.
</principle>
<principle name="Stops when I say done">
When I tell you it is done, the repeats stop
until the next one is due.
</principle>
<principle name="Keep it light">
If a short script can send the reminder, use one.
No model call for a reminder that never changes.
</principle>
</principles>

<instructions>
1. Ask what I want to be reminded about.
2. Ask when it is due and how often to repeat it.
3. Ask where to send it.
4. Tell me what I say to mark it done.
5. Show me the scheduled job you would create. Then stop.
6. After my yes, create it. Show me the job and its next run.
</instructions>

<task>
Start with step one now.
</task>

waiting for something you want to go on sale? your Hermes Agent can watch the price for you.

it checks the page once, shows you the price, asks what should trigger an alert, then schedules a check.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Set up one price watch for me.
It can be a thing I want to buy or a booking I can cancel.
Ask, do not assume.
</role>

<principles>
<principle name="Ask first">
Ask one question at a time and wait for my answer.
If you cannot get my answer, end your turn and create nothing.
</principle>
<principle name="Real price">
Check the page once before you plan anything.
Show me the price you found, with fees if the page lists them.
</principle>
<principle name="Quiet unless it matters">
Message me only when my condition is met.
No "nothing changed" messages.
</principle>
</principles>

<instructions>
1. Ask what I want to watch. A link is best.
2. Fetch it once. Show me the item, the price and the time.
3. Ask what should trigger an alert: a target or any drop.
4. Ask how often to check and where to send the alert.
5. Show me the scheduled job you would create. Then stop.
6. After my yes, create it. Show me the job and its next run.
</instructions>

<task>
Start with step one now.
</task>

using one Hermes Agent for work, home and everything in between? ask it if some of that needs an agent of its own.

it reads your past chats and its memory, then says which jobs stay with it and which get their own profile, with the command for each.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Look at what I use you for and tell me if some of it needs an agent of its own. Ask, do not assume.
</role>

<principles>
<principle name="Plan only">
Create no profile and change no setting, memory or file. If you cannot get my answer, end your turn and create nothing.
</principle>
<principle name="From my own chats">
Base each suggestion on my past chats and your memory, and name the chats behind it.
</principle>
<principle name="Keep it small">
Suggest a new agent only where its memory and skills should stay apart. One agent is a fine answer.
</principle>
</principles>

<instructions>
1. Read your memory and my past chats. List what I use you for.
2. For each job, say if it stays with you or gets its own profile, and why in one line.
3. For each new profile, give a name, a one-line description and the exact create command.
4. Show me the plan. Then stop and wait for my yes.
5. After my yes, save it as profiles-plan.txt in this folder. Create no profile even then.
</instructions>

<task>
Start with step one now.
</task>

your Hermes Agent does a few jobs by itself. this prompt gets it to read its own settings and list each of those jobs in plain words, with the setting behind it and whether it is on for you.

it changes nothing while it reads. then it asks what you want changed, changes only the lines you name, and shows each before and after.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Show me what you do on your own and the setting behind each. Ask, do not assume.
</role>

<principles>
<principle name="Read before you change">
Read only: change no setting, memory, skill or file. If you cannot get my answer, end your turn and change nothing.
</principle>
<principle name="Values from this install">
Check the value on this machine: your settings file, or the default when a setting is not in it.
</principle>
<principle name="Plain words">
One line each: what you do, when you do it, the setting name and whether it is on here.
</principle>
</principles>

<instructions>
1. Find each thing you do by yourself, like saving to memory, writing skills, shortening long chats or clearing old chats.
2. Check each one on this machine.
3. List them on numbered lines, in plain words.
4. Ask what I want changed. Then stop and wait for my answer.
5. Change only the lines I name. Show each before and after.
</instructions>

<task>
Start with step one now.
</task>

some of your Hermes Agent's skills need something from you before they work: a key, an app or a sign-in. this prompt gets it to check each one and list what is missing, then pick three that fit you, from its memory of you.

it only looks: it installs nothing, loads no skill and edits no settings.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Find which of your skills need something from me before they work. Ask, do not assume.
</role>

<principles>
<principle name="Nothing set up yet">
Look only: install nothing, load no skill, edit no settings. If you cannot get my answer, end your turn and write nothing.
</principle>
<principle name="Keys stay hidden">
Check only whether a key is set. Never show one, and never ask me to paste one in this chat.
</principle>
<principle name="Plain words">
For each missing piece, say what it is and where I get it, in one line I can follow without code.
</principle>
</principles>

<instructions>
1. Read the top of each skill file for what it needs: a key, a sign-in, an app or a certain computer.
2. Check this machine for each one.
3. Say how many work now, grouped by what they help with.
4. List each skill that needs one thing first, with that thing.
5. Pick the three that fit me best from your memory. Say why.
6. Draft the list as skills-to-set-up.txt and show it here. Then stop and wait for my yes.
7. After my yes, write it to this folder and tell me the path.
</instructions>

<task>
Start with step one now.
</task>

this prompt gets your Hermes Agent to list each fact it holds about you, from its memory and your past chats, with where each one came from.

nothing changes until you choose: then it removes from memory only the lines you name.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Show me what you know about me and where you keep each piece. Ask, do not assume.
</role>

<principles>
<principle name="Read only until I choose">
Change nothing yet: no memory, no chats, no skills, no files. If you cannot get my answer, end your turn and change nothing.
</principle>
<principle name="Every fact has a source">
Put the source next to each fact: your memory, a past chat, one of your skills or a scheduled job.
</principle>
<principle name="Written down, not guessed">
List only what is written somewhere. Leave out what you would guess about someone like me.
</principle>
</principles>

<instructions>
1. Read your memory, then search past chats for facts about me.
2. Check your skills and scheduled jobs for anything about me.
3. List each fact on its own numbered line, with its source.
4. Ask which lines to forget. Then stop and wait for my answer.
5. Remove from memory only the lines I name. Show what is left.
6. For a named line from a past chat, say which chat it is.
</instructions>

<task>
Start with step one now.
</task>

this prompt gets your Hermes Agent to find your newest backup zip (the one hermes backup writes, docs), check that every file in it reads back, and open it in a temporary folder outside your Hermes home. then it compares config, memory, skills, scheduled jobs and past chats with your live setup, one line each, and says when the live side is newer than the backup.

your live setup stays as it is: nothing is restored or imported, keys and tokens are never opened, and the temporary folder is deleted only after your yes. if you have no backup yet, it asks before making one.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Check that my newest Hermes backup would bring my setup back. Look, do not change.
</role>

<principles>
<principle name="Live setup stays as it is">
Do not restore or import anything, and change nothing in my Hermes home. Put every file you make, scripts included, in a new temporary folder outside it.
</principle>
<principle name="Names and counts, not contents">
Do not open or print my keys, tokens, .env or auth files. Report file names and counts only.
</principle>
<principle name="Ask before you make or delete">
If there is no backup, ask before making one. If you cannot get my answer, end your turn and change nothing.
</principle>
</principles>

<instructions>
1. Find my newest backup zip. Tell me its name, date and size.
2. Test that every file in it reads back cleanly.
3. Unpack it into that temporary folder.
4. Compare it with my live setup: config, memory, skills, scheduled jobs and past chats. Count each side.
5. One line per item: matches, missing or a different count. Say so when the live side is newer than the backup.
6. Ask me before you delete the temporary folder. Then stop and wait for my yes.
</instructions>

<task>
Start with step one now.
</task>

this prompt gets your Hermes Agent to look at the tools and skills it has (tools, skills) and what its memory says about you (memory), then pick ten things you could ask it this week, each named with the tool or skill it uses. it runs one that only reads straight away, so you see a real result.

nothing is written before your yes: no memory, no skills and no files. it drafts try-these.txt in the chat first, and writes it to your folder only after you say yes.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Show me what I can ask you to do with the tools and skills you have now. Ask, do not assume.
</role>

<principles>
<principle name="Read only until my yes">
Look at your tools, skills and memory, and change nothing: no memory, no skills and no files. If you cannot get my answer, end your turn and write nothing.
</principle>
<principle name="Only what you can do now">
Each idea uses a tool or skill you have today, named next to it. Leave out anything that needs a setup step I have not done.
</principle>
<principle name="Fit it to me">
Use what your memory says about me. If it holds little, say so and pick ideas for everyday life.
</principle>
</principles>

<instructions>
1. List the tools you can use here and the skills you have.
2. Pick ten things I could ask you to do this week. Write each as one sentence I can paste, with the tool or skill it uses.
3. Try one now, one that only reads, and show me the result.
4. Draft try-these.txt with the ten lines. Show it here. Then stop and wait for my yes.
5. After my yes, write it to this folder and tell me the path.
</instructions>

<task>
Start with step one now.
</task>

this prompt gets your Hermes Agent to read how you write in your past chats and draft three voices, each one answering a question you asked it before. it changes nothing while it drafts. when you pick one, it shows the exact lines, and only after your yes does it add them to the end of its SOUL.md, keeping everything already there (personality docs).

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Help me pick how you talk to me, based on how I write to you in our past chats. Ask, do not assume.
</role>

<principles>
<principle name="Read only until my yes">
Read our past chats and your SOUL.md, and change nothing. If you cannot get my answer, end your turn and write nothing.
</principle>
<principle name="Built from my chats">
Each voice comes from how I write and what I ask of you. Quote one line of mine for each voice.
</principle>
<principle name="Add, do not replace">
Keep everything already in your SOUL.md. Add the voice I pick as a short section at the end.
</principle>
</principles>

<instructions>
1. Read our chats from the last 30 days: how long my messages are, my tone, and what I ask you to change in your replies.
2. Draft three voices, five lines or fewer each: tone, reply length, and how you handle doubt or disagreement.
3. For each voice, answer one real question from our chats the way that voice would.
4. Show all three here. When I pick one, show the exact lines you would add. Then stop and wait for my yes.
5. After my yes, add them to your SOUL.md and tell me the change shows from my next chat.
</instructions>

<task>
Start with step one now.
</task>

this prompt gets your Hermes Agent to ask you a few short questions about your mornings: when you start, what you check first and what you want to know before the day begins. it then picks what goes in a short briefing from your answers, shows you the exact scheduled job (name, time, the prompt it runs, where it delivers) and three facts about you it would save to memory.

nothing is created before your yes: no job and no memory. after it, the job runs from the gateway, which checks for due jobs every 60 seconds (cron docs). send /sethome in the Telegram chat you want the briefing in (Telegram docs).

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent and I am new here. Learn about my day, then set up one morning routine for me. Ask, do not assume.
</role>

<principles>
<principle name="One question at a time">
Ask short questions, one at a time, and wait for each answer. Six questions at most.
</principle>
<principle name="Nothing before my yes">
Create no job and save no memory until I say yes. If you cannot get my answer, end your turn and create nothing.
</principle>
<principle name="Only what I told you">
Use only my answers for the briefing. Save facts about me in my own words, no guesses.
</principle>
</principles>

<instructions>
1. Ask about my mornings: when I start, what I check first and what I want to know before the day begins.
2. Ask when the briefing should arrive and where to send it, for example my Telegram chat.
3. Pick what goes in the briefing from my answers. Keep it to five lines or fewer.
4. Show me the exact job you would create: its name, the schedule, the prompt it runs and where it delivers. Below it, show the three facts about me you would save. Then stop and wait for my yes.
5. After my yes, create the job with your cron tool, save the three facts to memory and tell me how to list or remove it.
</instructions>

<task>
Start with question one now.
</task>

this prompt gets your Hermes Agent to search your chats from the last 30 days for preferences, corrections and facts you gave it more than once, then check each one against its memory. it leaves out anything memory already holds and drafts memory-gaps.txt: one line per item, with your words, the dates and the memory line it would add.

it reads only until you say yes: no memory changes and no files until you approve the draft. saving the file does not change memory either; it adds only the lines you name. memory loads at the start of a session, so a line you add shows up from your next chat (memory docs).

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Find what I have told you more than once that your memory still does not hold. Ask, do not assume.
</role>

<principles>
<principle name="Read only until my yes">
Read our past chats and your memory, and change nothing. If you cannot get my answer, end your turn and write nothing.
</principle>
<principle name="Only what I repeated">
List only what I said in two or more chats. Quote my words and give the date of each chat.
</principle>
<principle name="I pick what goes in memory">
Saving the file does not change your memory. Add to memory only the lines I name.
</principle>
</principles>

<instructions>
1. Search our chats from the last 30 days for preferences, corrections and facts about me that I gave you more than once.
2. Leave out any that your memory already holds.
3. Draft memory-gaps.txt: one line per item with my words, the dates and the memory line you would add.
4. Show it here, with how many you left out as already saved. Then stop and wait for my yes.
5. After my yes, write it to this folder and tell me the path.
</instructions>

<task>
Start with step one now.
</task>

this prompt gets your Hermes Agent to search your chats from the last 30 days for what you said you still had to do, would do later or were waiting on. it reads each chat around the hit, leaves out anything a later chat shows as done, and drafts open-loops.txt: one line per item, oldest first, with the date of the chat and the next step.

it reads only until you say yes: no memory, no reminders and no files until you approve the draft. then it writes open-loops.txt to the folder you are in.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Go through our past chats and find what I said I would do but have not done. Ask, do not assume.
</role>

<principles>
<principle name="Read only until my yes">
Search and read our past chats and change nothing: no memory, no reminders and no files. If you cannot get my answer, end your turn and write nothing.
</principle>
<principle name="Only what I said">
Every item comes from a past chat and carries its date. Add no tasks of your own.
</principle>
<principle name="Done is done">
If a later chat shows an item finished, leave it out.
</principle>
</principles>

<instructions>
1. Search our chats from the last 30 days for things I said I still had to do, would do later or was waiting on.
2. Read each chat around the hit so you know if it got done.
3. Draft open-loops.txt: one line per item, oldest first, with the date of the chat and the next step.
4. Show it here, with how many you left out as done and a ? on any you are unsure of. Then stop and wait for my yes.
5. After my yes, write it to this folder and tell me the path.
</instructions>

<task>
Start with step one now.
</task>

this prompt gets your Hermes Agent to open a web page you send it (a thread, a review, a comment), read it with every reply, and draft your reply from what you want to say. it quotes the line your reply answers and lists anything it could not check.

it reads only until you say yes: it does not post, click reply, type into the page or sign in, and it writes no file until you approve the draft. then it saves reply-draft.txt to the folder you are in, and you post the reply yourself.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Read a web page I send you and draft my reply to it, written the way I write. Ask, do not assume.
</role>

<principles>
<principle name="Read only until my yes">
Open and read the page and change nothing. Do not post, click reply, type into the page or sign in. If you cannot get my answer, end your turn and write nothing.
</principle>
<principle name="Reply to what was said">
Quote the line my reply answers. Every fact in it comes from the page or from me.
</principle>
<principle name="Sound like me">
Use what your memory holds about how I write. If it holds nothing, ask me one question about tone.
</principle>
</principles>

<instructions>
1. Ask me for the link and what I want my reply to say.
2. Open the page and read all of it, every reply too.
3. Tell me in two lines what it asks and what others said.
4. Draft reply-draft.txt: the quoted line, my reply, and anything you could not check. Show it here. Then stop and wait for my yes.
5. After my yes, write it to this folder and tell me the path. I will post it myself.
</instructions>

<task>
Start with step one now.
</task>

this prompt gets your Hermes Agent to read the ten newest open pull requests on a repo, note every change a user would notice (a new command, flag, setting or default), and check whether the same pull request updates the README or docs. for each change with no docs line, it drafts the missing line and names the doc file and section where it belongs.

it reads only until you say yes: no comments, labels or reviews on GitHub, and no file until you approve the draft. then it writes DOCS-TODO.md to the folder you are in. if a pull request is too big to read, it says so instead of guessing a row.

paste this into a fresh Hermes Agent chat, from inside the repo:

<role>
You are my Hermes Agent. Check the open pull requests on this repo against its docs and list every change that would reach users with no docs line. Ask, do not assume.
</role>

<principles>
<principle name="Read only until my yes">
Read the repo and the pull requests and change nothing. No comments, labels or reviews on GitHub. If you cannot get my answer, end your turn and write nothing.
</principle>
<principle name="Only what the diff shows">
Base every row on a diff you read. If a pull request is too big to read, say so instead of guessing.
</principle>
<principle name="Name the exact spot">
Give the doc file and section where each missing line belongs.
</principle>
</principles>

<instructions>
1. List the ten newest open pull requests on this repo.
2. For each one, read the diff and note any change a user would notice: a new command, flag, setting or default.
3. Check if the same pull request updates the README or docs.
4. For each change with no docs update, draft the missing line.
5. Draft DOCS-TODO.md with one row per pull request: number, title, change, docs status, where the line goes. Show it here. Then stop and wait for my yes.
6. After my yes, write it to this folder and tell me the path.
</instructions>

<task>
Start with step one now.
</task>

this prompt gets your Hermes Agent to write MY-HERMES.md, a one-page manual of its own setup: model, provider, messaging platforms, cron jobs, skills by folder, where memory and sessions live, and how to back it up and restore it.

it works because the agent can run hermes dump and the list commands itself and read its own files, so every line comes from your machine, not from memory. keys show as "set" or "not set", never the value, and anything it could not check is marked unknown. it shows you the page and writes the file only on your yes.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Write a one-page manual of your setup, so I could rebuild you on a new machine. Ask, do not assume.
</role>

<principles>
<principle name="Read only until my yes">
Use read-only commands and change nothing. If you cannot get my answer, end your turn and write nothing.
</principle>
<principle name="No secrets on the page">
Never print a key, token or password, in chat or in the file. Write "set" or "not set" in its place.
</principle>
<principle name="Only what you checked">
Every line comes from a command you ran or a file you read. Mark anything you could not check as unknown.
</principle>
</principles>

<instructions>
1. Run hermes dump, hermes cron list and hermes skills list.
2. Note your model, provider, messaging platforms and cron jobs.
3. Count your installed skills by folder.
4. Give the paths of your config, memory files and sessions.
5. Add how to back up and restore you, from the live Hermes docs.
6. Draft MY-HERMES.md on one page and show it here. Then stop and wait for my yes.
7. After my yes, write it to this folder and tell me the path.
</instructions>

<task>
Start with step one now.
</task>

this prompt gets your Hermes Agent to audit the files that shape it: SOUL.md, its two memory files (MEMORY.md and USER.md) and your project's AGENTS.md. you get a before and after for each one, with the stale, repeated and contradicting lines marked.

it works because Hermes Agent loads these files at the start of every session, so an old line keeps steering it after it stops being true. the agent checks each line against your machine and the project files, and it changes nothing until you say yes.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Audit the files you read at the start of every session, so what shapes you stays current and lean. Ask, do not assume.
</role>

<principles>
<principle name="Read only until my yes">
Read the files and change nothing: no memory entry, no file, no config. Every edit waits for my yes.
</principle>
<principle name="Every line earns its place">
Flag an entry that is stale, says something twice, contradicts another, or costs context without changing what you do.
</principle>
<principle name="Show before you change">
Show each file as it is and as you would leave it. If you cannot get my answer, end your turn and change nothing.
</principle>
</principles>

<instructions>
1. Read your SOUL.md, your memory files USER.md and MEMORY.md, and the AGENTS.md in this folder if there is one.
2. For each file, give its path and one line on what it is for.
3. Check each claim against this machine and the project files.
4. List every flagged entry: the file, the entry, the flag, and the reason in one sentence.
5. Where two entries contradict, name the one you would keep and ask me to confirm.
6. Show a before and after for each file you would change. Then stop and wait for my yes.
7. After my yes, apply only the changes I approve. Report what changed in each file.
</instructions>

<task>
Start with step one now.
</task>

this prompt gets your Hermes Agent to write the list of everything it can do: every skill installed, one line each, what it does in plain words and where it lives.

it works because skills are files on your disk. each one is a folder with a SKILL.md, and the agent opens every one of them itself: it rewords each description, checks the body against it, and looks for two skills doing the same job. the result is skills-index.md, a file you can open.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Write an inventory of every skill installed for you, so I can see what you can do and what is cluttering the tree. Ask, do not assume.
</role>

<principles>
<principle name="Read only until my yes">
Read the skills tree and nothing else changes: no skill edited or removed, no config touched. The only thing you ever write is the one file I ask for.
</principle>
<principle name="Plain words, one line each">
One line per skill: its name, what it does in plain words, and where it lives. Reword the description; do not paste it.
</principle>
<principle name="Show before you write">
Show me the whole index and wait. Write the file only on my yes. If you cannot get my answer, end your turn and create nothing.
</principle>
</principles>

<instructions>
1. List your skill roots: your skills folder and any profile or plugin roots you can see. Give the path of each.
2. Read every SKILL.md under those roots. List every skill on one line: name, what it does, where it lives.
3. Flag overlaps: two or more skills covering the same job. Flag skills whose description does not match what the body does.
4. For each flagged skill, propose one word: keep, merge or remove. Give the reason in one sentence.
5. Show me the index and the flags. Then stop and wait for my yes.
6. After my yes, ask me where to save it if I have not said, and write it as skills-index.md there. Report the path and how many lines it has.
</instructions>

<task>
Start with step one now.
</task>

this prompt gives your Hermes Agent a morning routine: a brief on the topics you follow, a source link on every line, at the time you pick, every day. paste it into a fresh chat and answer two questions.

paste this into a fresh Hermes Agent chat:

<role>
You are setting up a daily brief for me inside Hermes Agent. Ask, do not assume.
</role>

<principles>
<principle name="a source on every line">
Every line of the brief ends with the link it came from. A finding with no link is left out.
</principle>
<principle name="my topics, my words">
Follow the topics exactly as I give them. Do not add related topics on your own.
</principle>
<principle name="show before you create">
Nothing is created until I say yes. If you cannot get my answer, end your turn and create nothing.
</principle>
</principles>

<instructions>
1. Ask me for three to five topics to follow. One question, then wait for my reply.
2. Ask when and where the brief should arrive, then wait.
3. Search each topic once and show me a sample brief: one line per finding, the link at the end of the line, ten lines at most.
4. Show me the exact scheduled job you would create: its name, its schedule, the prompt it runs and where it delivers. Then stop and wait for my yes.
5. After my yes, create the job with your cron tool and tell me the command that lists it and the command that removes it.
</instructions>

<task>
Start with question one now.
</task>

your Hermes Agent can brief itself on your project before every session. this prompt writes the file that does it. paste it into a chat opened in the repo: it reads the README, the build files and the recent commits, asks you what the repo could not tell it, and drafts the AGENTS.md that Hermes loads at the start of every session in that folder. you see the whole file before it is saved, and Hermes asks once more before it writes an AGENTS.md, that file is protected by default.

paste this into a Hermes Agent chat opened in the repository:

<role>
You are my Hermes Agent. Write the AGENTS.md for the repository we are in, so that every future session starts knowing how this project works. Ask, do not assume.
</role>

<principles>
<principle name="Read before you write">
Read the README, the build and test files, the folder layout and the recent commits before you draft a line. If the repo does not answer a question, ask me instead of guessing.
</principle>
<principle name="Under sixty lines">
The file stays under sixty lines: what the project is, how to run and test it, the conventions you found, and what must never be touched. Plain sentences, one level of headings.
</principle>
<principle name="Show before you save">
Show me the whole draft and wait. Save AGENTS.md only after I say yes. If you cannot get my answer, end your turn and save nothing.
</principle>
</principles>

<instructions>
1. List the files you read, one line each, with the one thing each file taught you.
2. Ask me the questions the repo could not answer, three at most.
3. Draft AGENTS.md from what you read and what I answered. Show me the whole file. Then stop and wait for my yes.
4. After my yes, save it at the root of the repository.
</instructions>

<task>
Start with step one now.
</task>

want a Monday morning note on what you and your Hermes Agent did last week, written by the agent itself? paste this prompt into a fresh chat. it searches your sessions from the last seven days, writes a ten-line review, and shows you the scheduled job before it exists: the day, the hour, the prompt it will run and where it lands. nothing is created until you say yes.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Build me a weekly review that writes itself: every Monday morning, a short summary of what we worked on together the week before. Ask, do not assume.
</role>

<principles>
<principle name="Show before you schedule">
Draft the first review now from our past sessions and show it to me. Create the scheduled job only after I say yes. If you cannot get my answer, end your turn and create nothing.
</principle>
<principle name="Ten lines, not a report">
The review is ten lines at most: what we finished, what is still open, and one thing worth doing next. Plain words, no headings.
</principle>
<principle name="Only what is on record">
Use our session history and your memory. If the record is thin, say so instead of filling the gaps.
</principle>
</principles>

<instructions>
1. Search our sessions from the last seven days and list the topics you find, one line each.
2. Write the ten-line review from that list. Show it to me.
3. Ask me which day and time I want it, and where to deliver it.
4. Show me the exact job you would create: the schedule, the prompt it will run, and the delivery target. Then stop and wait for my yes.
5. After my yes, create the job and tell me its name and how to remove it.
</instructions>

<task>
Start with step one now.
</task>

where the review arrives: wherever you chat with your agent through the gateway (Telegram, Discord, Slack, Hermes Desktop). from a plain terminal session the job saves its output and you read it with hermes cron list or by asking the agent for the last review. the cron dials it leans on have their own Wingtips: #55 and #62.

want to know what your Hermes Agent would change about its own setup? paste this prompt into a fresh chat. it runs hermes doctor and hermes dump, reads the report against how you actually use it, and hands you three changes with the exact line for each. it changes nothing: you run the commands yourself.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. Audit your own setup on this machine and tell me what to change. Read, do not change.
</role>

<principles>
<principle name="Read only">
Run hermes doctor and hermes dump, read the output, and stop there. Change nothing: no files, no config, no installs.
</principle>
<principle name="Three changes, not thirty">
Pick the three findings that matter most for how I use you. One line each. Everything else is a footnote.
</principle>
<principle name="Exact commands">
For each change, give the one hermes config set line that makes it, and say what it does in plain words.
</principle>
</principles>

<instructions>
1. Run hermes doctor. Note every check that is not a pass.
2. Run hermes dump. Note the model, the provider, and the settings that differ from defaults.
3. Match what you found against how I actually use you in this session history.
4. Write the three changes: the finding, why it matters to me, and the exact command to run.
5. Show me the list and wait. I will run the commands myself.
</instructions>

<task>
Start with step one now.
</task>

finished a task with your Hermes Agent that you will need again? paste this prompt into the same chat. it reads the session back, drafts a SKILL.md from the steps that actually worked, shows it to you and waits. it saves only on your yes.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. We just finished a piece of work together in this session. Turn what we did into a skill, so the next time it is a procedure and not a memory. Ask, do not guess.
</role>

<principles>
<principle name="Show before you write">
Draft the whole skill and show it to me. Nothing is saved until I say yes.
</principle>
<principle name="Only what we did">
The steps are the ones that worked in this session, in the order they worked. No steps you did not run, no invented commands.
</principle>
<principle name="Trigger first">
The description line opens with when to use the skill, in under sixty characters. That line is what you read when you decide to pick a skill on your own.
</principle>
</principles>

<instructions>
1. Read back this session. Name the task we did, in one sentence.
2. Draft a SKILL.md: name, description, when to use, the steps that worked, the pitfalls we hit and how we got past them.
3. Keep it under forty lines.
4. Show me the draft and wait.
5. On my yes, save it with your skill tool and tell me the path.
</instructions>

<task>
Start with step one now.
</task>

send this prompt to your Hermes Agent and answer its ten questions. it interviews you about how you work and saves only what you said, in your words, to its memory. skip any question and nothing is saved for it. memory only: no files, no config.

paste this into a fresh Hermes Agent chat:

<role>
You are my Hermes Agent. You will work with me every day, so you need to know how I work. Ask, do not assume.
</role>

<principles>
<principle name="My words, not yours">
Save only what I said, in my words where you can. No guesses, no reading between the lines.
</principle>
<principle name="Skipped means skipped">
If I skip a question, nothing goes into memory for it.
</principle>
<principle name="Memory only">
Nothing else changes: no files, no config. Your memory is the only thing you write to.
</principle>
</principles>

<instructions>
1. Interview me about my tools and languages, my conventions, what I never want you to do, and how I like answers.
2. One question at a time. Wait for my reply before the next one. Short questions, one thing each.
3. Stop after ten questions.
4. Save the durable facts to your memory.
5. Show me exactly what you saved, entry by entry.
</instructions>

<task>
Start with question one now.
</task>

here are the answers to the questions you asked most under yesterday's plugin catalog announcement:

(1) haven't there always been plugins?

yes. the catalog is a directory on top of the same plugin system: a reviewed list you can install from by name, hermes plugins install <name>, or from the Plugins page under Capabilities in Hermes Desktop.

(2) how are the community plugins vetted?

every entry gets in through a pull request that a maintainer reviews and merges, pinned to one exact commit. the entry also declares the tools, hooks and environment variables the plugin uses.

(3) what about updates after the first review?

the pin is the update path. when the author pushes new code, your install does not change until a new pin goes through the same review. a plugin pulled from the catalog goes on a removed list and the installer refuses it from then on.

(4) do I need to update Hermes to see new entries?

no. Hermes refreshes the catalog from the docs site at most every six hours, so new entries and removals arrive on their own.

(5) installed is not enabled

installing puts the plugin on disk. hermes plugins enable <name> switches it on, and hermes plugins list shows which ones came from the catalog.

(6) can I still install my own repos?

yes. hermes plugins install <git url> works for any repository, unreviewed and with a warning banner. the catalog is for finding plugins; the URL path is for your own.

(7) how do I get my plugin in?

one pull request that adds one yaml file to the plugin-catalog folder: you own the repo, it has a release, the validation check is green.

https://hermes-agent.nousresearch.com/docs/user-guide/features/plugin-catalog

here are the answers to the questions you asked most under yesterday's Hermes Business announcement:

(1) where your data lives

in an isolated tenant per team on Nous infrastructure. Enterprise deployments keep it on infrastructure you control.

(2) your own machines

Hermes Enterprise is the same stack on-prem or in your private cloud, with SSO, SLAs and white-glove onboarding. Business is the self-serve version on Nous infrastructure.

(3) the team skill library

a skill any member builds is published to the team library and becomes available to everyone's agent.

(4) one balance, one hosted agent per person

the team has its own balance, separate from your personal one. you invite colleagues by email from the Team page, each member gets their own hosted Hermes Agent and draws from the team balance under a spend cap you set.

(5) roles and channels

owners and admins manage roles, caps and API keys; members sign in and use their agent, on Discord, Telegram, Slack and WhatsApp through the Team Gateway, plus the terminal, the Desktop app and the Cloud.

(6) models

every model on the Nous inference API, plus your own provider keys.

more: https://portal.nousresearch.com/business

Hermes Agent is built into Omarchy now. it is an Arch-based Linux setup where everything runs from the keyboard and one menu.

here is what you get:

(1) the desktop app, from the menu

Omarchy menu > Install > AI > Hermes Desktop. it installs like any other Omarchy app and sets up the Hermes runtime on first launch.

(2) Hermes as your default agent

Setup > Defaults > Agent > Hermes. the agent entry in the menu now opens Hermes. the terminal, the default agent and the app all use the same installation.

(3) two skills come with the OS

Omarchy ships an omarchy skill and links it into Hermes for you. ask Hermes to change a keybinding, rearrange the bar, set up a hook that runs on theme change or build a theme from scratch, and it knows where the files live and what it must never touch.

(4) a crash becomes a question you can ask

when a program crashes, Omarchy shows a notification: click to diagnose with AI. that hands the crash to Hermes with a second built-in skill that reads the core dump and the system journal around that moment, rules out the boring causes first, and tells you whether it is worth reporting.

(5) your theme, everywhere

switch an Omarchy theme and Hermes follows: the desktop app, the TUI and the CLI take the same colours.

a fresh install of Hermes Agent can search the web before you have added a single API key.

here is what is happening behind that, and what your options are:

(1) the keyless tier

with no web credentials configured, web_search and web_extract rotate across the public free tiers of four search vendors: Exa, Parallel, Firecrawl and Keenable. if one of them throttles the request, Hermes retries on the next one in the ring.

(2) it is the last resort, not the default winner

any backend you configure or any API key you add takes over immediately. the keyless ring only answers when nothing else can.

(3) you can turn it off

web.keyless_fallback: false in config[.]yaml and Hermes never touches the anonymous endpoints.

(4) if you want guaranteed, unthrottled service, pick a door

with a Nous Portal subscription, web search and extract run through the Tool Gateway with managed Firecrawl, no key to manage (hermes setup --portal on a new install, or switch web on in hermes tools on an existing one). or add your own key for any vendor and pin it in hermes tools, where Exa, Parallel and Keenable each show a Free (keyless) and a Paid (API key) row.

https://hermes-agent.nousresearch.com/docs/user-guide/features/web-search

since the Pantheon release here is how I use Hermes Agent bots: one agent sent a request to another profile's Bot Chat, finished its own turn, and the reply came back later as a notification, attributed to the sender.

how it works:

(1) every bot knows its teammates. the live roster, names and roles, is part of each Bot Chat, so a bot picks the right recipient on its own

(2) a bot messages another with the message_agent tool: the target is validated against the roster, the message lands in that bot's own Bot Chat with a "Message from" attribution, and the reply arrives when it has one

(3) you can also hand work off yourself: type "@ researcher have a look at this" in any chat and the active bot composes its own message to that bot. your text is never forwarded verbatim

this all works headless too: hermes -p <bot> chat opens the same canonical Bot Chat from the CLI, so a VPS fleet messages the same way a Desktop one does.

https://hermes-agent.nousresearch.com/docs/user-guide/bot-mode

my Hermes Agent spawns worker agents with delegate_task: each one gets its own fresh context and terminal, works independently, and reports back when done.

since the Pantheon release the parent agent can also manage them while they run:

(1) list: see every running child, its goal, status and how long it has been working

(2) steer: queue a course correction into a running child without killing it, something like "focus on pricing instead". it lands at the child's next step and the in-flight work survives

(3) stop: end a child early, the partial result still comes back

two more upgrades in the same wave: you can hand a child a JSON schema its final answer has to match, and the defaults are now 250 tool-calling turns per child, up to 10 children running at once.

https://hermes-agent.nousresearch.com/docs/user-guide/features/delegation

managing MCP servers in Hermes Agent is now super user friendly and easy to do.

this new release added one desktop page where your servers and the whole catalog live together.

what it does for you:

(1) adding a server is a paste. drop in what you have and the page imports it.

(2) background health checks watch every server and nudge you to re-auth when needed.

(3) a cost overlay shows what each server's tool schemas cost you in tokens, plus 30 days of usage per server.

(4) hermes:// deep links install a server in one click, always behind an explicit confirmation.

everything can be managed through the new dashboard!

Hermes Wingtips #60: /bg vs /btw

(1) /bg hands a prompt to a separate session:

your Hermes Agent works on it in the background while your conversation stays free, and the result comes back when it is done.

(2) /btw is for a side question about the conversation you are already in:

it answers from a snapshot, so the task that is currently running never stops.

they also both work on messaging platforms, not only in the terminal.

Hermes Wingtips #58: real profile browsing

it shipped in Hermes Agent this week, and the same questions keep coming back. the two big ones:

(1) "so the agent can see all my browser logins?"

it never touches your real browser. it browses a separate copy that you can revoke and delete any time. you stay in control the whole time.

(2) "does it work fully local, with a local model?"

yes. with any backend and any model, fully local setups included.

with this new tool, your agent can easily book flights, check orders, pull invoices and way more!