Found something good?

In February 2026, Nous Research released Hermes Agent: an open-source, self-hosted agent that doesn't live inside an IDE and doesn't forget when the tab closes. It runs as a daemon on your own box, keeps memory across sessions, takes scheduled jobs in plain language, and writes its own reusable skills from experience.

It became one of the fastest-moving open-source agents of the year: a runaway GitHub star count and one of the most-used agents on OpenRouter. It recently went terminal-native with a new TUI.

Then I ran it as my own standing infrastructure for 5 weeks, on a $5 VPS, with Claude as the model underneath.

The tool is real. But a blank Hermes install does nothing on its own. It's a runtime, not a workflow. What turns it from "interesting repo i starred" into "thing that did 3 hours of my work overnight" is the prompts you give it on day one, and almost nobody shares those.

So here are mine. Below: the 17 prompts and config lines i actually paste, the moments that earned the sharpest ones their place, and the 3 mistakes i made first so you can skip them.

If you want to skip the explanations and just paste, the full set is at the end.

Why this matters

Almost every AI tool you use is session-based. Claude Code, Cursor, the chat window: you open it, work, close it, and the context dies with the session. That's the right design for what they do, and Claude Code is still the better tool for coding inside a single project.

But a whole class of work isn't session-shaped: the brief that should be ready before you wake, the build that should be watched whether you're looking or not, the inbox filling while you're heads-down. Session tools can't hold it, because they aren't running when it happens.

That's the gap Hermes fills. It's persistent (memory survives the session), scheduled (it acts on a clock, not your attention), and reachable (Telegram, Discord, Slack, email, not a tab you forgot). The model thinks. Hermes keeps it pointed at your work when you're not there.

A blank install gives you all of that capability and zero of the workflow. The prompts below are the workflow.

The setup: three things before any prompt runs

Before any prompt does anything, three things have to be true. Two are config commands (recipes 15 and 16 below); the third is just where you run it. Pulled up front so the rest makes sense:

Get those three set and the 17 prompts below have something to run on. Skip them and recipe 1 dies the first night.

The 17 prompts I actually run

Some of these earned their place with a specific failure. For those i'll show the moment; for the rest, just what it does and the prompt.

1. The 7am brief instead of a notifications pile

The first job every persistent agent should own is the thing you do half-asleep before real work starts.

The moment: I was spending the first 35 minutes of every morning doing this by hand across 6 repos, before a single line of real work. Five days a week, that's about 3 hours a week of triage i was doing at my most expensive time of day, on autopilot. Now it's waiting in Telegram before i sit down, and the 35 minutes is gone.

2. The repo watch that only speaks when it matters

A monitor that pings you for everything gets muted in a day. The skill is in the silence.

The moment: a red CI on a Friday deploy i didn't see until Monday, three days of broken main behind a ten-minute fix. now it pings in ~90 sec and stays silent otherwise.

3. Inbox triage across every channel you own

Hermes connects to Telegram, Discord, Slack, WhatsApp, Signal and email from one process, which means triage can finally happen in one place.

The moment: Roughly 120 messages a day across six platforms, and a client DM that sat unanswered for two days because it was buried under Discord noise. The escalation rule, deadline, a person waiting, or money, is the whole prompt. Everything else gets archived and i never see it.

4. The Friday research digest that dedupes itself

Effect: ~2 hr of Friday feed-scrolling becomes a 5-bullet read. the dedupe clause is the trick: it remembers last week, so what lands is genuinely new.

5. "Make sense of this repo" in one message

Effect: the cold-start day on an unfamiliar codebase compressed to a ~4 min map good enough to start from. not a substitute for understanding the code, a substitute for not knowing where anything is.

6. The long task you hand off at night

Effect: the "don't wait on me, make assumptions and list them" clause is what turns a 2am stall into a result waiting by morning.

7. Watch competitors' changelogs, not your feeds

Effect: you hear about a competitor's move the morning it ships, not when a customer brings it up.

8. The nightly review of your own code

The moment: I shipped a console.log with a token in it and didn't notice for a week. The nightly pass now catches that class of thing before i'm awake, and the list is usually three lines, sometimes zero. It's the cheapest code review i run.

9. The stand-up it writes for you

Effect: you walk into stand-up with it already written, instead of reconstructing yesterday from memory.

10. A radar for your own name

Effect: the angry user and the quiet bug report find you, instead of you finding them three days late.

11. Turn a 90-minute talk into 5 bullets

Effect: the talk everyone's quoting, read in two minutes, with timestamps for the parts actually worth your 90.

12. "Explain this error and propose the fix"

The moment: A production stack trace i'd normally lose an hour bisecting. I handed it over and got the failing line, a two-sentence cause, and a three-line patch back before i'd finished reading the trace myself. I still review the patch. I just don't hunt for the needle anymore.

13. Inbox-zero, but it drafts the replies

Effect: the dozen "sounds good, Thursday works" replies are written and waiting for your yes, not your attention. Nothing leaves without your tap.

14. An on-call agent that diagnoses before it pages you

Effect: the 3am page arrives with a hypothesis attached, not just a red light. A subagent with its own terminal does the log pull, so the diagnosis costs you nothing.

15. Point it at Claude (one line, no lock-in)

The moment: I started on a cheap local model to keep costs near zero. It dropped tool calls halfway through any multi-step job, because it couldn't hold the context a real workflow needs. Recipes 1 through 14 all quietly failed in ways that were hard to debug.

Swapping the model to Claude in one line fixed every one of them at once, because the failures were never the prompts, they were the model underneath. You can swap back with the same command, there's no lock-in.

16. Serverless backend so idle costs almost nothing

The moment: My first month ran on an always-on backend, and the idle compute, the 23 hours a day it sat doing nothing between jobs, quietly added up to more than the work itself cost. A serverless backend hibernates when idle and wakes on demand, which took the standing cost of a 24/7 agent down to pennies between jobs.

17. Turn a good run into a permanent skill

The moment: I re-explained the exact format of my morning brief four times before it occurred to me to make it permanent. Hermes writes its own SKILL.md from the run and reuses it after that, so the fifth time i just said "run the morning brief" and it knew. This is the compounding part: every prompt that works once becomes a capability you never type again.

The numbers

I logged the same week of standing work twice: once done by hand the way i always had, once handed to Hermes running these prompts. Same week, same tasks.

Unattended = ran on schedule or async with no input from me after the initial prompt.

The headline isn't the hours saved, though there are several. It's that none of this work happened at a time i had to be awake for. The brief runs at 7 whether i'm up or not. The repo is watched on a weekend. The research lands Friday night. The scarce resource was never the time, it was my attention, and the point of a persistent agent is that the work stops competing for it.

What didn't work

The first two weeks were mostly me learning what a prompt to a standing agent has to contain that a prompt to a chat window doesn't.

Where this bites

Three honest tradeoffs, because self-hosting an always-on agent isn't free of strings.

You're the admin now. Updates, uptime, and the permission model are yours. An agent that remembers everything and acts on your machine has to be kept on a tighter leash than a chatbot that forgets when the tab closes.

It runs shell commands on your behalf. Set a Docker or serverless backend with isolation before you give it real access, not after it's already touching your files. The sandbox is a day-one decision, not a later one.

The hype is loud. Star counts swing wildly between blog posts and a lot of the "deployment guide" content is affiliate noise. Judge it by what it does for your week, not by the leaderboard.

The full set (copy-paste ready)

Two config lines set once, then fifteen prompts pasted into the agent. That's the 17: fourteen jobs, plus the one that turns any good run into a permanent skill.

How to install

One command for the runtime, then run the setup wizard:

hermes setup walks you through connecting Telegram, Discord, Slack, WhatsApp, Signal or Email and runs it as a service. Then paste the config and prompts above.

The mental model

A prompt to a chat window is a question. A prompt to a persistent agent is a job description: it needs a trigger (a schedule or an event), a body (what to do), and an escalation rule (when to bother you). Drop any of the three and the prompt either never fires, does the wrong thing, or buries you in noise.

That's the whole shift. You stop thinking "what do i want to ask" and start thinking "what standing work do i want off my plate, and on what terms do i want to hear about it."

Your week isn't my week. If you don't live across six chat platforms, skip recipe 3. If you never touch unfamiliar repos, skip recipe 5. Paste the 17, keep the ones that map to work you actually repeat, and delete the rest. Three recipes tuned to your real routine beat seventeen you set up once and never read.

Closing

Nous Research shipped a runtime that a lot of people starred and a lot of people use. Most of them are still staring at a blank install, because the repo gives you the engine and not the route.

The engine isn't the point. The point is that the brief is ready at 7, the build watches itself over the weekend, and the research lands while you sleep, none of it competing for your attention because none of it needs you in the loop.

17 prompts. 5 weeks on a $5 VPS. Three hours of my week that no longer happen while i'm awake.

If this saved you a morning, repost it. Part 2 next week: the cron schedules and self-written skills that survived a month, and the three i deleted.

The work runs. You don't have to be awake. bookmark -> paste the prompts into a fresh install tonight repost -> if it saved you a morning of triage more: t.me/aiXmnimi