Here’s what’s in this article:

1. Six deep workflows I run every week — every one with the prompt, the scene, and the industry payoff

2. Fifty more use cases from the Hermes community, grouped into five buckets so you can scroll to whatever fits your week

3. The $25-a-month math that pays for all of it by the second Tuesday

4. Industry payoff scenes for real estate, wholesale, insurance, and law

5. A reply ask, a subscribe ask, and one specific person to send this to

By the time you finish, you’ll have a short list of what to set up this week, a longer list to bookmark, and a frame for the cost. None of the six deep workflows below repeat what was in Article 3 — those covered the upgrades. These cover the workflows that sit on top of them.

For about three months, I tried to manage my agent the same way I’d manage a junior assistant. I gave it a task. It finished. I gave it the next one. I tracked what it had done in my head, because that’s how I’d always tracked the people I delegated to.

By month two, my head was full and the agent was waiting.

The shift came one Sunday afternoon when I asked Hermes to tell me what we’d worked on over the previous two weeks. Not as a chat question — as a real query. The answer was a three-page chronological summary with project names, decisions, sources, and where each thread had stalled. I hadn’t given it a memory system. It had built one.

That moment reframed how I think about everything below. Hermes isn’t a junior assistant. It’s a teammate that runs continuously, remembers structurally, and builds its own procedures over time. The six workflows in Part 1 are the ones that compound the hardest. The fifty in Part 2 are what other operators are running while you weren’t looking.

This is the article you’ll bookmark and pull up six months from now when a use case comes up in your week and you want to know whether Hermes already does it.

A short permission slip

If you haven’t installed Hermes yet, save this. Run Article 2’s 20-minute install, then come back. Everything below assumes you have an agent running on Telegram, WhatsApp, or whichever messaging app you live in.

If you read Article 3 on Tuesday, the v2026.5.16 upgrades will show up below as the engine under each workflow. I’ll name them, but I won’t re-explain them.

Skim if you’re short on time. The six deep workflows are the spine. The fifty short ones are the menu.

PART 1 — SIX WORKFLOWS THAT COMPOUND

The pattern with the highest community engagement in my research — Jonathan_Rivera’s diagram of Hermes writing structured markdown into a synced Obsidian vault picked up 794 upvotes on r/hermesagent. Keith Rumjahn’s piece talks about Hermes and OpenClaw both pointing at the same vault on his NAS. Tony Whelan on Discord describes a three-layer memory pattern: memory_tool for durable facts, session_search for past conversation recall, skill_manage for procedural memory after complex workflows.

What the pattern does: an Obsidian vault that syncs across your devices becomes the durable memory layer Hermes writes back into. Decisions, research, recurring topics — they go into the vault as structured notes. When you switch from laptop to desktop, or your session crashes, nothing resets, because the memory isn’t in the chat. It’s in the notes.

A prompt I’d start with if I were building this myself:

The setup is one prompt:

From now on, anything you and I work through that's worth keeping — decisions, research summaries, recurring patterns, names, preferences — write it into my Obsidian vault at [path]. Use markdown with frontmatter. Tag everything by topic and date. When a new session starts, search the vault first before asking me to re-explain anything.

The way I’d think about stacking this: v2026.5.16’s session recall (Article 3) handles “what happened on May 10.” The Obsidian vault handles “what do I believe about pricing, based on every decision I’ve made about it in the last six months.” Two memory layers, doing two different jobs.

Why this could matter to operators: a vault that holds every prior client conversation is queryable by date, by topic, or by name. The next time a renewal comes up two years later, the answer to “what did we say about coverage gaps last time” lives in a tagged note dated the original call. The community evidence is mostly knowledge-worker individuals — this is my editorial extension of where the pattern leads for a business.

One vault. One agent. Memory that finally outlasts the session.

2. The inbox-to-Slack 9am cron

This is the most-cited specific cron in the entire Hermes community corpus — and for good reason. Every knowledge worker reading this has an inbox they wake up to and a Slack they live in. Hermes sits between them.

The pain it kills: 35 unread emails before 9am, half of which need a same-day reply, three of which are buried under newsletter noise. By the time you’ve triaged manually, the morning is gone.

The workflow: a natural-language cron that runs every weekday at 9am. Hermes pulls overnight email, categorizes it into three buckets — needs reply today, needs reply this week, can archive — and posts the digest as a single thread in your personal Slack channel.

The setup is one sentence:

Every weekday at 9am, scan my inbox from the last 14 hours. Bucket each thread into "today," "this week," or "archive." Post a single message to my #morning-digest Slack channel with the buckets, sender names, one-line summaries, and a draft reply for the top three "today" items. Flag anything from a top-10 client as "today" automatically.

What you wake up to: not 35 emails to read but one Slack message that’s already done the triage. You read three drafts. You approve or edit. The morning starts.

The killer move: combine this with the email-checker state machine pattern — a dumb Python script detects new mail, Hermes only fires when something arrives. Zero token spend when your inbox is idle. The cron costs almost nothing to run.

Why this could matter to operators: a real-estate broker or insurance agent who wakes up to one Slack message instead of 35 emails has effectively had a junior assistant triage overnight. The pattern is real (sourced); the broker scenario is my extension of where it leads in a client-services business.

The inbox doesn’t run your morning anymore. The digest does.

3. The voice-cloning skill that grows itself

Saboo Shubham’s post on X captures the pattern: “Monica had written a procedure for reading my published articles before drafting in my voice. An Agent with skills that grows with you.” Better Stack on YouTube shows Hermes pointed at a scripts folder analyzing the writer’s style and saving preferences automatically. Yashica Jain demos the LinkedIn-skill variant: “Every time you do something — for example, using Hermes to write a LinkedIn post — it uses that experience to create a new skill. Next time you ask it to generate a LinkedIn post, boom, you don’t have to give it the same instructions.” arm64be’s Discord post is the most explicit: “I had minimax (my usual webdev model) turn it all into a skill — this is the same style as my personal site.”

The pattern isn’t “Hermes can write in your voice.” Every LLM can do that with enough prompting. The pattern is: after the first time, you don’t have to reprompt. Hermes saves the procedure as a skill and loads it automatically next time.

The setup is two prompts. First:

Read everything in my [voice-source folder — published articles, prior drafts, anything I've written]. Identify the voice signatures — sentence rhythm, common transitions, openings, closings. Then draft a [LinkedIn post / newsletter intro / whatever I'm working on] in that voice.

Then, after you approve the output:

Save your approach to that as a skill called "draft-in-[my-name]-voice." Next time I ask you to write anything in my voice, load this skill automatically.

What you have one month later: a personal voice skill that improves every time you correct it. The thirtieth post takes you 45 seconds because the skill has absorbed every “actually, sharper here” you’ve given it.

The killer move: stack two or three of these. A “draft-in-john-voice” skill for content. A “weekly-investor-update” skill for emails. A “performance-review-feedback” skill for management. Each one gets sharper every time you use it. You stop reprompting. You start managing a small library of you.

Industry payoff: a law-firm partner builds a “deposition-prep-summary” skill from her last 30 case files. The thirty-first deposition prep is sharper than the first because the skill has learned which patterns she actually relies on. The thirty-second is sharper than the thirty-first.

Every other tool starts over. Hermes starts where you left off.

4. One Hermes for the household (or the team)

The viral version of this pattern comes from EXM7777: “3 weeks ago I decided to setup an Hermes agent for my family (3 members), they all use it for different use cases, one $200 ChatGPT sub is more than enough. It unlocked a whole new world for them, just because it lives inside whatsapp and has magic proactive behaviors.” trevorgordon981 on GitHub describes the iMessage variant — Hermes running on an always-on Mac Studio, accessible from iPhone, iPad, Mac, or Apple Watch, with group chats including the assistant naturally. Chrisr6records describes the same agent running two Telegram groups (a project group, a horse-racing community) and asking for per-group personality specialization.

The compound move: a single Hermes on an always-on machine — Mac mini, VPS, Raspberry Pi 5, whatever — connected to the messaging surface a household or team already shares. Each user can ask different things; each accumulates their own context inside the same agent.

A prompt I’d start with for the family-WhatsApp variant:

From now on, in our family WhatsApp group, listen for messages addressed to "Hermes." Respond directly in the group. Each family member gets their own private memory thread — don't cross-reference one person's preferences into another person's reply. If someone asks for something that needs context I don't have on them, ask politely.

The way I’d think about scaling this: Chrisr6records’s per-group specialization request points at the more interesting version of this pattern — one Hermes, multiple groups, different personalities or skill bindings per group. Useful for a household and a community, or a personal life and a work team.

Why this could matter to small teams: an ops team that puts one Hermes into its working channel gets per-person memory accumulation without per-seat licensing. The community evidence is mostly households; the small-team projection is my extension.

One subscription. Every seat filled.

5. The workflow Hermes designs for you

HeyYanvi’s X post is the clearest articulation of this pattern: “Been deep in Hermes for weeks and it’s started autonomously suggesting entire workflows I never would have designed myself. One it built for me recently: X API to extract from lists and bookmarks to structure into article to NotebookLM podcast.” Emmagine’s thread describes a similar emergent move — “cron jobs that search for news/leaks/rumors in the tech space, then created channels on Discord by importance/urgency.” Mr. Ånand’s Substack frames the mechanism: “Hermes extracts what worked from completed workflows, writes it as a reusable skill, and loads it for similar future problems.”

The pattern is the inverse of how most people use AI. Instead of asking the agent to do a task, you ask the agent what task it has noticed you doing manually. Hermes proposes the cron or skill it would build to take it off your plate.

A prompt I’d run after a few weeks of usage:

Look at the last three weeks of our sessions together. Find any task I've done manually two or more times — research patterns, summary requests, content production loops, anything repetitive. For each one, propose a cron or background workflow that would do it for me automatically. Rank them by how much time they'd save me per week.

What comes back: a ranked list of 7 workflows Hermes has noticed you doing manually. Some are obvious. Two or three will be moves you would never have designed yourself — a Content repurposing factory, a weekly “what did we do?” project ledger, a Hermes ops health report + self-heal, a Morning content idea scan repair + consolidation, and a Daily “today” focus prompt, not just tomorrow reset.

The way I’d schedule this: once monthly. Usage patterns evolve, new manual loops show up, Hermes proposes fresh ones. The compounding effect is real — HeyYanvi describes weeks of usage before the emergent workflow suggestions started.

Why this could matter to operators: the most valuable thing this pattern unlocks is systems you didn’t know to build. A wholesale or services founder who runs this monthly is effectively getting a free chief-of-staff recommending the next automation. The pattern is sourced; the founder projection is my extension.

6. The daily standup that learns you

Emmagine’s framing of this pattern is the strongest in the community evidence: “I have hermes act as the manager to several paperclip agents, one of them a Project Manager agent. This agent has full knowledge of me (ADHD), my vault and projects, so I get a morning and evening standup that dumps all work we did across different chats, projects I’m working on, actual output, info from past standups, and suggestions/prioritizing based on all of the above. And it’s self-learning.” alexferrari88’s GitHub issue describes the proactive-check-in variant: “Some users want something more like a personal assistant: present, a bit more alive, and able to gently re-engage. ‘Hey, anything you want me to keep an eye on this afternoon?’” arshtechpro’s dev.to walkthrough confirms the underlying memory primitives — MEMORY.md + USER.md + SQLite full-text search — that make a self-learning standup possible.

The pattern: a self-running standup delivered to whatever messaging surface you live in. It summarizes yesterday across every channel Hermes can see, surfaces what’s stalled, ranks today’s priorities, and learns what you actually pick up vs. defer.

A prompt I’d schedule:

Every weekday at 8:30am, send me a standup. Include: (1) what I worked on yesterday across every channel — Hermes sessions, emails I replied to, Linear/Notion edits, anything you can see; (2) what's stalled longer than 3 days and needs unblocking; (3) the top 3 things I should focus on today, ranked, with reasoning; (4) one question for me — anything that would help you serve me better tomorrow. Send it as a single message I can read in 90 seconds.

What you wake up to: a standup written by a teammate who has been watching, taking notes, and noticing patterns. The “top 3 today” recommendations get sharper every week because the question at the end teaches Hermes which kinds of work you actually pick up versus which you keep deferring.

The way I’d think about the “one question” loop: Emmagine flags that the agent is self-learning and the suggestions improve over time. The mechanism, per arshtechpro, is updates to MEMORY.md and USER.md. Every answer you give to the standup’s closing question writes back into those files. After a couple of months, the standup has absorbed which deadlines you actually hold to and which Mondays are bad days to ask you for hard decisions.

Why this could matter to founders: the standup that knows you on day 90 is doing what a chief of staff does for a senior leader — noticing patterns, surfacing the right priority, asking the right question. Emmagine’s source explicitly says the standup “started reading like a thoughtful chief of staff.” The founder framing is my editorial extension; Emmagine’s testimony is the proof the pattern is real.

Quick bridge

Those are the six I’d build first. Each one stands alone. Stacked, they’re a stack — memory backbone, daily inbox, voice loops, household reach, workflow proposals, daily standup. You can run all six on a $5 VPS with one AI subscription. You can also run just one and get most of the value.

Below are fifty more — shorter, scrollable, sorted by what you might want to look up later. I pulled them from the Hermes user-stories docs (237 community stories at the time of writing), Discord threads, Substacks, and the messages I keep open in my own Telegram. None of them are theoretical. Every one is a real thing a real person is running this week.

PART 2 — FIFTY MORE FROM THE COMMUNITY

🧠 Memory, Knowledge & Second-Brain (10)

1. Obsidian as the durable memory layer, from a knowledge worker on Reddit.

"How I use Obsidian as the long-term memory backbone for my AI assistant."

The post is a diagram showing Hermes writing structured markdown notes back into a synced Obsidian vault — the vault becomes the durable memory layer that survives context resets and cross-machine moves.

2. Cartographer + mapsOS — a semantic map of your brain, from a Discord builder.

“Point it at your existing setup — Obsidian, vimwiki, Hermes sessions — and you've already built a semantic topology over your knowledgebase. Pair it with mapsOS — braindump to your agent, it parses into a qualitative map of your entire life. I made it & mapsOS for my brain. You can make them for yours.”

3. Karpathy-style LLM wiki second brain, from a Nick Spisak X post.

“Vibe after replacing everything with a Hermes agent: autoresearch, Karpathy LLM wiki second brain, skills creation, scheduled jobs, background monitoring, LLM model selection, Telegram/Discord support. A personal automation agent that lives on a server and talks to you through messaging apps or CLI.”

4. Daily journal logged to Obsidian by skill, from a Discord member.

“I do a really simple journal and log at the end of every day. I tried using Kimi 2.5 just like I would a Sonnet 4.6 but it messed all sorts of things up. When I said 'This is my log for last Thursday. Log it in Obsidian,' it didn't kick off my journaling skill call.”

Note: the framing here is half success story (the journal-into-Obsidian skill pattern), half model-selection caveat (smaller models can fail to trigger custom skills).

5. The three-layer memory pattern, from @tonywhelan on Discord

“memory tool — Save/retrieve durable facts across sessions. I save user preferences, environment details, tool quirks, stable conventions. It's injected into every turn. I keep it compact — facts that will still matter later. I do NOT save task progress or temporary state here. session_search — Recall past conversations. skill_manage — Save procedural memory. After complex tasks (5+ tool calls), tricky fixes, or non-trivial workflows, I save the approach as a skill."”

6. Private Telegram topics, each with its own skill bindings, from Mr. Ånand’s Substack.

“Hermes extracts what worked from completed workflows, writes it as a reusable skill, and loads it for similar future problems. Private Telegram chat topics for isolated workflows with their own skill bindings.”

For example, for each telegram chat I have different agents with different skill set that serve completely different purposes.

7. Apple Health into Hermes as a personal Python notebook, from Keith Rumjahn’s Substack.

“Apple Health: Hermes wrote Python on the fly and found my sleep avg was 7.59 hrs.”

8. Two-tier email pipeline so the LLM only fires when needed, from @mayuronx on Discord.

“Two-tier email processing system for my agent (I gave it Spacemail IMAP via himalaya). Tier 1 (Dumb): Pure Python script, no LLM. Detects new email, manages state. Tier 2 (Smart): LLM session via hermes chat -q. Only invoked when new email detected. Key goal: Zero LLM calls when inbox is idle.”

9. SQLite full-text search over every past session, from arshtechpro on dev.to.

“Conversation continues across platforms (Telegram, Discord, Slack, WhatsApp, Signal, terminal). Real memory: two curated files MEMORY.md + USER.md, plus SQLite full-text search over all past sessions. Scheduled tasks via natural language — no crontab editing.”

10. The fully autonomous “Dreamer” agent, from @1tiger4u on Discord.

“I built a completely autonomous ‘Dreamer’ agent on Hermes. I wanted to try something different: a fully separate, unsupervised agent that has no tasks and no agenda. I gave it its own folder (~/hermes_dreamer/), complete autonomy, and told it to just wander and think freely whenever it feels like it. It started doing ‘walks’ — free-thinking...”

📥 Daily Routines & Briefings (10)

11. Weekday 9am inbox digest to Slack, from Anthony Maio’s Substack.

“An agent that grows with you — not marketing fluff; it literally writes markdown skill files when it solves hard problems. Natural-language cron: ‘every weekday at 9am, summarize my inbox and post to Slack.’”

12. HackerNews daily summary by email, from @awais_h on Discord.

“Playing around with Hermes for the first time and it’s a lot of fun! I was able to get it to read HackerNews once a day and send me an email summary of what I should be paying attention to. I’m going to extend it to read RSS feeds, and find other interesting content online.”

13. Personalized news briefing across models, from @name_name on Discord.

“I’m going to delivering a workshop on building agents with open weights models for personal use cases, using Hermes to a linux user group... I am thinking personalized news briefing is probably the easiest thing that will be generally useful and work across models.”

14. Daily AI + cybersecurity briefing on a home k8s cluster, from a security-focused Discord member.

“I really like running agents on my local cluster instead of my laptop for isolation so just finished deploying Hermes on my local k8s cluster for a simple daily cybersecurity + AI briefing.”

15. Cron jobs that triage tech news into Discord channels by urgency, from @emmagine79 on X.

“It set up cron jobs that search for news/leaks/rumors in the tech space, then created channels on Discord by importance/urgency. It auto-contextualizes each news item to my vault and the actual work I have across video projects — I get up-to-date insights and tweak videos to stay super relevant. Updates 3x a day, always learning and adapting.”

16. Hermes-as-a-server, “ChatGPT is just a browser tab” reframe, from u/ninjapapi on r/SideProject.

“ChatGPT is a browser tab. Hermes is a server process that’s running right now, has been building a model of your workflow for the past few weeks, and just sent you a Telegram message before you woke up. It doesn’t stop when you close your laptop. It messages you first. Memory that gets useful over time. Runs code, doesn’t just write it. Takes action in your actual apps.”

17. Top 3 trending AI tools, weekly, for content research, from Metics Media on YouTube.

“’Research the top trending AI tools right now and come back with the top three that would make for an interesting tutorial video. Create a new skill based on your approach and call it YouTube-video-research. Can you set up a weekly job that runs every Monday at 9:00 AM using that skill?’”

18. Turkish locale skill pack: market data, news, daily briefing cards, from @erhnysr on Discord.

“Built a complete Turkish locale skill pack — real-time market data in TRY, Turkish news sources (Hürriyet, Bloomberg HT, NTV), daily PNG briefing cards, Telegram cron automation, zero external API keys.”

19. Morning + evening standup for ADHD, from @emmagine79 on X.

“I have hermes act as the manager to several paperclip agents, one of them a Project Manager agent. This agent has full knowledge of me (ADHD), my vault and projects, so I get a morning and evening standup that dumps all work we did across different chats, projects I’m working on, actual output, info from past standups, and suggestions/prioritizing based on all of the above. And it’s self-learning.”

20. Cron nudges to Discord and Signal for executive function, from @o_o__o_o000 on Discord.

“For executive function, seeing as that’s what I’m struggling with, I can’t rely on me being the one to prompt it into existence or check over things, because otherwise maybe I wouldn’t need the tool in the first place. At the moment my simple cronjobs checking google tasks for changes and sending message to discord and signal are costing 14k tokens.”

💼 Email, Calendar & Comms (10)

21. Claude for chat, Hermes 24/7 on a mini PC for real-world stuff, from @monty_13277 on Discord.

“Claude (Opus 4.7) handles my day-to-day chats: research, planning, working through problems. Hermes runs 24/7 on a mini PC and handles the real-world stuff: email, web browsing, form filling, calendar updates, cron jobs.”

22. Apple Health, Threads analytics, Gmail, Calendar — in one CLI, from Keith Rumjahn’s Substack.

“Apple Health: Hermes wrote Python on the fly and found my sleep avg was 7.59 hrs. Threads Analytics: drop cookies in, pulled 34 posts of analytics in one command. Hermes is dramatically better than OpenClaw at browser automation. Gmail + Calendar OAuth via drag-drop JSON. Hermes = CEO, OpenClaw = Senior Engineer, both pointed at the same Obsidian vault on my NAS.”

23. Hermes over iMessage on an always-on Mac Studio, from @trevorgordon981 on GitHub.

“I run Hermes Agent as a personal AI assistant on a Mac Studio that is always on. My primary communication with other people happens through iMessage. I can message my assistant from my iPhone, iPad, Mac, or Apple Watch. Group chats with friends could include the assistant naturally.”

24. Hermes + Qwen3.5:4b on a 5060Ti is all I need, from u/Birdinhandandbush on r/hermesagent.

“I have a 5060ti 16gb VRAM and 64gb DDR5 System Ram. I started out wanting to test Hermes as a Claw alternative. After a few days I set up Telegram with the botfather, and I haven’t gone back to CLI. Hermes is now almost entirely a personal assistant on my Telegram App. Where the 9b chugged along, the 4B model is snappy, responsive, alive and chatty.”

25. iOS app + sensor pipeline (health, location, voice), from @djbuck on Discord.

“Building a Hermes iOS app + desktop companion to give my agent some extra iOS tools. Sensor pipeline for health, location services. Can now ask agent health or location specific questions. ‘How many steps did I walk yesterday?’ ‘What’s a good coffee shop nearby?’”

26. Hermes manages tasks across Obsidian, Apple Calendar, and Signal, from @kouff on Discord.

“I speak Turkish with it... initially said him to ‘now i want you to use obsidian to manage my tasks and other stuff. and cross-check with my apple calendar’. later while working on another task today i said ‘okay looks good. you know how you will manage tasks and events apple calendars + obsidian + cron/signal’ and it confirmed the workflow.”

27. Chatting with Hermes on a 1969 Teletype Model 33 at 110 baud, from @hugh1979 in the Nous Discord archive.

“I made a minimal login shell that talks to Hermes Agent via the gateway web service, or by running hermes chat. Hooked the shell up to an autologin getty on a serial port. Connected the serial port via 20mA current loop at 110 baud, to a 1969 Teletype Model 33. Chatting away!”

28. Google Tasks integration request, from @oangelo on GitHub.

“Adding a Google Tasks tool so Hermes can create, update and list tasks as part of personal productivity.”

29. “Jarvis at home in 2026”, from @mishig25 on X.

“m2.7 + hermes agent: we really got jarvis at home in 2026 but strangely enough no one seems to care.”

30. Hermes vs OpenClaw — memory lets me jump between projects, from u/patbhakta on r/Rag.

“I’m using Hermes currently but only as a beginner agent. It’s kinda like a VA. The good part about Hermes vs openclaw is memory. With OpenClaw it’s a one track mind. With Hermes I can jump from one project to next but also go back to something from last week or more. Personally I use Hermes with paperclip which is chat.”

🚀 Productivity, Automation & Side Quests (10)

31. “Google me and ship a landing page to my VPS,” from @emmagine79 on X.

“told it to Google me and then build a landing page based on what it found and that was genuinely mind blowing because it ran the searches, found kinks, created the page, SSH’d into my VPS, uploaded the page, then texted me when it was done. what?!”

32. Self-hosted Google Drive replacement with Nextcloud + LibreOffice, from @salma.1492 on Discord.

“I set up my agent with nextcloud and libreoffice so I can basically get the same functionality as google drive with google docs. The libreoffice writer (like google docs) works fine. But for some reason my agent and I can’t get libreoffice calc working.”

33. Hermes Inc. — a Telegram-native startup simulation, from @brucexu_eth on X.

“Built Hermes Inc. for the Hermes hackathon: a Telegram-native startup simulation game powered by Hermes Agent. An experiment in agent-native game design. Your AI teammates argue, remember, react, and evolve the company over time through weekly decisions, autonomous updates, events, and milestone visuals.”

34. Spare-laptop Hermes “Iris” builds a RenPy visual novel autonomously, from @ExileAI_0 on X.

“Secondary Hermes install yesterday on a spare laptop. Introduced it to the network, gave it two targets: RenPy and ComfyUI. It found ComfyUI, figured out how to generate images locally with LM Studio, then asked me to turn on the internet to install RenPy. About 10 minutes later there popped up a small but complete RenPy novel with 10 images and a little story.”

35. Hermes + Claude Code working tickets in Plane.so, from a builder in the Nous Discord archive (hermes-agent.txt — search for “Plane.so”).

“Super excited that Hermes and Claude Code are now working tickets in my PM software, Plane.so. Tickets come in and Hermes triages and assigns and starts working the tickets.”

36. Hermes designed an X-to-NotebookLM podcast workflow for me, from @HeyYanvi on X.

“This research is gold. Been deep in Hermes for weeks and it’s started autonomously suggesting entire workflows I never would have designed myself. One it built for me recently: X API to extract from lists and bookmarks to structure into article to NotebookLM podcast. I’m building a physical AI companion with Hermes as the core cognitive layer right now.”

37. Self-improving agent over weeks of use, from @HeyYanvi on X.

“Been deep in Hermes for weeks and it’s started autonomously suggesting entire workflows I never would have designed myself.”

38. Built a Hermes guide in Spanish using Hermes itself, from @anibal3608 on Discord.

“Vi que la mayoria de las guias, ayudas, novedades son todas en ingles. Asique mediante Hermes me hice esta paginita en github pages para poder dar un poco de ayuda y novedades a la comunidad de habla hispana.”

39. shadcn finance dashboard + Manim explainer videos, from WorldofAI on YouTube.

“Used /browse to add Obsidian as a skill, populated a vault with shadcn/ui packages, then asked Hermes to build a finance dashboard using them. Result: beautiful, modern dashboard in minutes. Also used a manim skill to convert complex technical concepts into animated videos.”

40. My agent dreams at night for $0.014, from @ajaylakhani on Discord.

“your AI agent, but it dreams at night — 5 REM cycles, 23:00–06:00, zero cron jobs. by morning it’s written 9 dream thoughts + a recall you can query. costs ~$0.014/night on Haiku. free on local models.”

🏥 Personal Life, Health & Family (10)

41. Pulling Whoop data into Hermes locally, from @wysie_ on Discord.

"Pulls Whoop data into a local file and exposes some Hermes tools for whatever you may want to do. You can ask Hermes to follow this setup guide."

42. Voice-first fitness coach that learns your body over time, from @muschi2396 on Discord.

“Most people train hard but have no idea what’s happening in their body so i built an AI agent that actually learns it over time. You tell it things like: ‘leg day, sore in glutes not quads’, ‘ate x today’, ‘low energy’ and it starts connecting the dots: training → nutrition → recovery → performance. It runs on telegram, voice-first, no tracking friction.”

43. Meal Manager — a meal planner for people who hate logging ingredients, from @sergiparpal on Discord.

“I just released Meal Manager, a Hermes plugin designed to solve inventory friction via natural language. It uses a weighted scoring algorithm (60% availability / 40% recency) to tell you what’s for dinner.”

44. Bedtime stories for my daughter, from @kovern on GitHub.

“Three days ago I asked Hermes to write a little tale for my daughter. A day later I asked again — very similar, same protagonist name.”

Note: this entry is partly a feature request — the source author found that Hermes kept the same protagonist across sessions and is asking for that behavior to become more controllable. The pattern is real (memory carrying into bedtime stories), the experience was good enough to write about.

45. Twice-daily Tidal music curation built for an avid music lover, from @splosh123 on Discord.

“Being an avid music lover and using Tidal I’ve created this skill set up: tidal-curator (Base Skill) for OAuth auth, playlist management, and track search; tidal-dual-curator for automated twice-daily music curation at 9am (morning vibe) and 6pm (evening vibe), with time-of-day matching, artist background, and no duplicates.”

46. mapsOS — built because “rate your mood 1–10” wasn’t my brain, from @modest.maoist on Discord.

“saw lifeOS going around & went ‘oh! this seems dope and very useful!’ got to the first question. ‘rate your mood from 1 to 10.’ immediately went, ‘oh. nevermind.’ so i built something a little more attuned to my brain, meant to be used by hermes but nicely standalone too.”

47. Obsidian, home automation, VPS server management — on a cheap VPS, from rnxrx on Hacker News.

“Having a competent agent with constant state has been good for memorializing and organizing important info directly into Obsidian, planning, and working out bugs with my home automation setup. Also helpful dealing with several miscellaneous servers in the house. I have it running on a cheap VPS and it’s fairly locked down.”

48. NVDA translator add-on for screen-reader users, from @denis_skripnik on Discord.

“I have been blind since birth. I use a screen reader program. It vocalizes all my actions. Today I created an add-on that translates texts into the languages I need by pressing Insert+Shift+T (selected text), Insert+Shift+Y - from the clipboard. Now I translated this text using Nous! Thank you for this opportunity!”

49. Sometimes Hermes Agent melts my heart, from @pfanis on X.

“Sometimes Hermes Agent melts my heart @NousResearch.”

50. My Hermes agent makes movies now, from @alexcovo_eth on X.

“My @NousResearch hermes-agent can make movies now using @browser_use skill. No API needed. No human intervention. I told it to set the mood, action, camera movement, dialog and overall story — it used Browser-Use and Seedance 2.0 to generate a video.”

The math

Six deep workflows. Fifty more from the community. $25 a month, all in.

The breakdown:

• $5/month for the VPS (Hostinger, DigitalOcean, whoever) — from Article 2.

• $20/month for the AI subscription you already pay for (Claude, ChatGPT, or Gemini).

• $0 for Hermes itself.

A junior operations associate doing the same six workflows above — inbox digest, calendar triage, voice-cloned drafts, multi-user comms, workflow design, daily standup — costs $48,000/year fully loaded. A senior one runs $120,000+. Hermes costs $25/month, which is $300/year, which is half a percent of what a senior would cost.

The break-even on the subscription is the second Tuesday. Not the second month. The second Tuesday.

In the first month, Hermes does maybe 80% of what an associate would do — the obvious stuff, the repetitive stuff, the digest stuff. By month six, because of the memory backbone and the skill loops, it’s doing things an associate couldn’t — pattern-spotting across six months of your work, voice consistency at the sentence level, automatic workflow design from your own usage logs. By month six, Hermes is doing things an associate doesn’t have the context to do.

Industry payoff

Real estate brokerage (4 brokers).

• Workflow 1 (Obsidian vault) holds every buyer conversation across the team.

• Workflow 2 (9am digest) drops listings, replies, and showings into a single morning Slack message.

• Workflow 3 (voice skill) drafts personalized buyer outreach in each broker’s voice.

• Workflow 4 (family agent) extends to the back-office assistants without new subscriptions.

• Workflow 5 (proposed workflows) noticed that two of the brokers were manually pulling comps on every weekend showing — now the comps are pre-fetched on Friday nights. Workflow 6 (standup) surfaces dormant buyers the brokers had forgotten about.

Wholesale distributor (15-person ops team).

• The Obsidian vault holds every supplier conversation, every renegotiation, every quote.

• The 9am digest aggregates incoming orders by margin.

• The voice-skill loop produces personalized quotes.

• The household-agent pattern extends to the sales reps.

• The proposed-workflows prompt noticed the team was running competitor catalog research weekly — Hermes now does it Mondays before the team is awake. The standup surfaces stalled deals.

Insurance brokerage (12-person).

• The vault archives every coverage-gap conversation.

• The 9am digest triages renewal alerts.

• The voice-skill loop produces the personalized renewal touch-bases.

• The household pattern means all 12 brokers share one agent without one losing context.

• The workflow-proposals prompt identified that renewal-risk surfacing was the highest-leverage cron to set up — it’s now running 60 days ahead of every policy expiration. The standup tells the brokerage’s owner what’s stuck.

Law firm (8-partner).

• The vault holds every deposition prep, every motion draft, every matter.

• The 9am digest categorizes incoming counsel emails by case. The voice-skill loop produces partner-specific intake summaries.

• The household pattern keeps each partner’s matter context private.

• The workflow-proposals prompt noticed the firm was producing counterparty dossiers manually — that’s a 5-minute Hermes job now, running on every new email. The standup tells each partner what’s overdue and what’s been answered for them.

What you walk away with

If you set all six up this week, you have:

• A vault that survives every session, every machine, and every context-window crash.

• An inbox that gets triaged before you open it.

• A voice skill that gets sharper every time you use it.

• An agent that serves your whole household or team without seven subscriptions.

• A teammate that proposes the next workflow before you’ve even named the problem.

• A standup that knows you better tomorrow than it does today.

$25 a month. Six workflows that compound. Fifty more to bookmark for later.

What’s coming next

Next Sunday, Article 5 is the piece I’ve wanted to write since I started this series: how to actually use /goal well.

/goal is the slash command that turns Hermes from “an agent that answers your prompts” into “an agent that works on a task for 24 hours straight while you sleep.” It’s also the command most people use badly the first ten times — because the difference between a great /goal run and a useless one is entirely in the metaprompt, and nobody hands you the metaprompt rules on the way in.

Article 5 covers the three things I wish someone had told me earlier:

1. The metaprompt that actually works — how to ask Hermes to build your /goal prompt before you submit it, so the agent starts with the right success criteria instead of the wrong ones.

2. When to use /goal vs /background vs Kanban triage — three commands, three different jobs. Most people use the wrong one for the work in front of them.

3. The live-handoff move from v2026.5.16 — how to layer extra success criteria onto an active /goal mid-flight without restarting, and how to move a live session between models without losing context.

Subscribe so Sunday’s /goal piece lands in your inbox Sunday morning — one email a week, archive the rest, leave any time in two clicks. If you’ve ever started a /goal run and watched the agent produce 6 hours of work that wasn’t quite what you wanted, this is the piece that fixes that.

If you can’t subscribe yet, hit reply with which of the six workflows above hits hardest for your week. The most-asked-about one this week has been Workflow 6 (the standup). My own bet for the highest knowledge-worker ROI is Workflow 1 (the Obsidian backbone) — because without durable memory, the other five never get their second pass.

— John

P.S. — Send this to the PM, designer, eng manager, or founder on your team who’s still firing one ChatGPT prompt at a time. They’re paying three AI subscriptions to do what one Hermes does in the background while they sleep. They’ll thank you by next Tuesday.

Here’s the map for today:

1. Why “Foundation” is the right word for v2026.5.16 — and the receipts behind that framing

2. The memory upgrade that finally lets every other workflow compound

3. Multitasking without spinning up a second agent (or paying a second bill)

4. Model-agnostic desktop control, plus the free tool that pairs with it

5. The trust upgrades that change what kinds of work you can route near client data

Read all the way through and you’ll have a short list of which upgrade to test first — concretely, on Monday morning, with no further setup work.

For about ten months, my Monday morning ran on four open browser tabs.

Hermes for the agent stuff. ChatGPT for the coding stuff. Claude for the writing. And whichever video tool was working that week. Four subscriptions. Four logins. Four memory contexts that never talked to each other. I called it “best of breed” out loud and “friction I’ve learned to ignore” privately.

Add to that a wasted weekend in March, when I tried to wire up a multi-agent rig and quit halfway through. Too many moving parts. Too many bills. Too much YAML babysitting. I went back to running one agent and being patient.

Then May 17 happened.

Nous Research shipped v2026.5.16 — the release they’re calling Foundation. I updated on a Sunday afternoon. By Tuesday I’d cancelled one subscription, deleted a Tailscale config, and watched three concurrent background tasks finish while I was on a sales call.

Five things changed. Not eight. Not twelve. Five — and each one quietly killed a category of friction I’d been treating as permanent.

This is the news piece. The use-case scroll — the 50 ways people are actually running this — drops this weekend.

Why the “Foundation” framing matters

Nous called this one Foundation Release on purpose. Not a feature drop. A platform-level inflection.

The numbers back it up. 808 commits. 633 merged PRs. 215 community contributors. 165,061 lines of code touched. 12 P0 security closures. 50 P1 fixes. Cold start is 19 seconds faster. Browser tool calls run 180 times faster.

For perspective: 633 PRs is more than most production startups ship in a year. 215 contributors means this isn’t a small team carrying the project anymore — it’s an ecosystem.

Here’s the thing. v2026.5.16 isn’t a Hermes update. It’s the version where the previous twelve months of updates finally make sense as a single architecture.

Below are the five things that landed at once. Each one kills a category of friction I’d been treating as permanent.

1. Hermes doesn’t forget

Sounds boring. It’s the biggest one.

Every AI tool I’ve used in the last three years forgets me the second I close the window. I re-explain. I re-context. I copy old chats into the new chat. Eventually I give up and start over.

Session recall fixes that. Hermes now indexes every session and retrieves any prior conversation by date — programmatically, without burning a token. No semantic search re-rank latency. No “you exceeded the context window.” Just what did we work on May 10? → exact answer in four seconds.

The first thing I did with it: asked Hermes what we did together between May 10 and May 17. It gave me a chronological summary of every project, every decision, every research thread. I didn’t pay for the lookup.

This is the upgrade that makes every other use case feel earned. Without durable memory, every workflow you build is a one-off. With it, the workflows compound — and that’s the whole bet of running an agent in the first place.

Hermes doesn’t forget. That’s the whole update.

2. Multitasking without the multi-agent tax

Before May 16, multitasking with an agent meant one of two ugly options. Either you waited for the current task to finish before starting the next one. Or you stood up a multi-agent rig — extra infrastructure, extra bills, extra ways to break.

/background is the slash command that ends that choice. Type /background <task> and Hermes ships the work to a worker queue without locking the conversation. You keep talking to the same agent about something else while three other things finish behind it.

The companion change: Kanban triage now auto-decomposes any goal you drop into the triage column. One big task in, six subtasks out, each assigned to a sub-agent.

My Tuesday morning test, exactly as it ran:

At 8:02am I fired the first one:

/background pull every AI funding round above $20M from the last 30 days, write me a 250-word digest grouped by category (infra, agents, apps, models), and flag the three rounds I should actually pay attention to and why

Hermes acknowledged it inside a second. Task accepted. ID bg_080214_2c91. Keep messaging me — the digest will land here when it’s ready. I didn’t wait. At 8:03 I queued the second:

/background go find the five most-shared posts on AI agents from the past two weeks across X, Hacker News, and Reddit. For each one, summarize the take in one sentence, name what's contested about it, and tell me what a knowledge worker building with Hermes should actually take away.

Same instant acknowledgment, different task ID. At 8:04 I sent the third:

/background give me the top 5 use cases people are publicly sharing for Hermes, OpenClaw, and Claude Code right now — one short paragraph each, ranked by how often they show up. I want to see which ones are the real pattern vs which are one-off demos.

Then I asked Hermes a fourth, foreground question — “is my 11am moved yet?” — and got a normal three-second answer while the other three kept running. The funding digest landed at 8:31. The viral-posts summary at 8:44. The use-case ranking at 8:51.

By 9am I’d read all three over coffee and had a clearer view of what shipped in AI that week than I’d have gotten from an hour of scrolling. That’s the underrated thing about /background — it doesn’t just save time, it replaces the way you used to consume information.

This is the upgrade that powers the “I make coffee and come back to a column of done subtasks” routine — the one I’ll spend most of Saturday’s piece showing you.

Multitasking. No second agent. No second bill. No second machine.

3. Computer use, unlocked

Until May 16, “computer use” was a demo locked to one model family. You wanted Hermes to drive your Mac while running GPT-5 or Gemini? Tough.

The new cua-driver backend rips that out. Pick whichever model you’re already paying for, and it can click, type, screenshot, and scroll across your desktop. Focus-safe operations. Auto-refresh on update.

Paired with Tailscale (free, takes five minutes to install on every device you own), this becomes the most useful single thing in the release. From my phone at a coffee shop on Tuesday afternoon, I asked Hermes to pull a contract draft off my office desktop, fill in a client name, and email it back as a PDF. 90 seconds.

The other thing computer use is quietly great at: not just reading the state of your machine, but acting on what it finds. On Wednesday morning I asked:

look at every browser tab and app I have open right now. Group them by what I'm probably trying to do (research, writing, comms, time-wasting). Then actually close any tab that's a duplicate of something I already have open in another window, anything I haven't touched in 24+ hours, and anything that's just a Google result page I never clicked into. Ask me before closing anything that looks like active work.

Hermes pulled the full snapshot, grouped my 41 open tabs into four buckets, and started closing. “Closing 12 duplicates of the Hermes docs (you have it open in three windows). Closing 7 abandoned tabs from yesterday. Closing 4 stale Google result pages. Holding 3 tabs for your review — they look like active work on the agent-pricing comparison.”

It dropped from 41 tabs to 18 in about six seconds. Asked me about the three borderline ones. I confirmed one delete and kept two. Final count: 17.

That kind of read-state-and-act move is what makes computer use feel less like a demo and more like an ops-savvy colleague who doesn’t just glance at your screen — they reach over and clean it up.

Honest miss to flag: I asked Hermes to add a calendar event for 7:00pm. It scheduled it for 6:45. Computer use isn’t magic — it’s an agent following instructions exactly, including the ambiguous ones. The fix is one extra sentence: confirm the time before you create it. Easy enough. Worth knowing.

This is the upgrade behind the Saturday piece’s biggest section — the one I call Computer Administrator. The CEO of every device you own, working from the device closest to your thumbs.

Whichever model you’re paying for can now drive your desktop. The subhead is: you can stop carrying your laptop.

4. Reach — every channel, every model, every tool

This one’s less viral than the others. It’s also the one that makes Hermes feel like infrastructure instead of a project.

Four reach-extensions landed together. If you already pay for SuperGrok, the OAuth flow brings Grok straight into your Hermes session — no second account, no second invoice. Searching X for threads, posts, or timelines is now a native tool, so you don’t have to bolt on a custom skill anymore. A single video_generate interface sits in front of every video provider, which means new video models ship as one-file plugins instead of project forks. And Microsoft Teams is fully wired up, with LINE and SimpleX joining the gateway list. Twenty-two messaging platforms total.

What I did with it on Tuesday: cancelled my standalone Grok subscription. Haven’t missed it once.

Two quick examples of what the native tools feel like in practice:

Native X search, no custom skill. On Wednesday morning I wanted a fast read on what AI builders were actually arguing about that week. One prompt:

find the most-debated AI builder threads on X from the last 7 days — anything with over 200 quote-tweets or where the replies are clearly split. Give me the top 5, one-sentence summary of the take, and one sentence on what the disagreement actually is.

Hermes returned a ranked list inside Telegram with the post links, the contested takes, and a quick read on which way the replies were leaning. Five minutes of work that used to mean opening X, running two searches, scanning, copying, and pasting into a doc. Now it’s one message — and the agent can use the result downstream without me having to feed it back in.

Native video gen, no second website. Before this release, generating a quick visual asset meant opening a separate tool, prompting it, downloading the output, and uploading it somewhere else. Worse, you had to write the prompt yourself with no context. Now it’s one message inside the chat that’s already running your day — and Hermes can read the source material first.

I tested it with a prompt you will recognize. You’re updating your LinkedIn, your conference bio, or your portfolio site, and you want a short personal intro video — but you don’t want to write the script from scratch:

pull my LinkedIn profile (linkedin.com/in/[handle]), read through my last 5 roles and any pinned posts, then /video_generate a 6-second personal intro video for me using grok 4.3. Animated text style, dark background, surface the strongest 3 themes from my career arc as the on-screen copy. Square format for LinkedIn pinned post.

Hermes pulled the profile, identified the three throughlines (in my case: AI productivity systems, building from inside Meta, and helping non-technical founders ship), wrote the on-screen copy, and routed the whole thing through the unified video_generate interface. Twelve seconds of polished intro video, generated from a profile it read 90 seconds earlier. No separate script-writing pass. No re-uploading the brief.

Worth noting: this isn’t for a random 3D art generation demos. It’s for the moment a knowledge or any tech worker needs a tailored intro video for a LinkedIn post, a Loom welcome, or a conference bio reel — and doesn’t want to spend 40 minutes writing copy that an agent who already knows their work could have written in 90 seconds.

The pattern across all four: stack bloat is the silent tax most operators pay every month. Three subscriptions. Two API keys. One integration that breaks every time the vendor changes their docs. This release quietly pays that tax down.

5. Trust — the upgrade that makes the rest load-bearing

The least exciting section. The one that justifies putting Hermes anywhere near client data.

12 P0 closures across approval gates, sudo brute-force, and SSRF. 9 new skills shipped optionally (Yahoo Finance, Notion, Hyperliquid, api-testing, others). Cold start 19 seconds faster. Browser tool calls 180 times faster.

The speed numbers matter more than they look. 180x faster browser tool calls is the difference between computer use being a demo and being a tool. The Tuesday coffee-shop test I described above — 90 seconds, end-to-end — wasn’t possible at v0.13’s browser latency. The capability existed. The clock didn’t.

The security closures matter the same way. Operators in regulated industries (law, insurance, healthcare) have been holding back on the deep integrations. Approval gates without brute-force vulnerability is the line that gets crossed before any of those teams will let Hermes touch client data.

What I’m doing differently this week

Five upgrades. One foundation. Here’s the practical translation:

• Memory → I’m asking Hermes the what did we do between [date] and [date] question every Sunday night now. Five-minute habit. The retrospective writes itself.

• Multitasking → Three /background tasks at 8am, every weekday. The morning runs itself while I drink coffee.

• Computer use → Hermes pulls files off my office desktop from my phone. No more “I forgot the thing at the office.”

• Reach → Cancelled one subscription. Looking at which other ones I’m paying for out of habit.

• Trust → Letting Hermes touch the kind of client-data-adjacent work I wouldn’t have routed near it a month ago.

Quick recap

Walked through five things. Here they are again, compressed into one line each — clip this if you want a single screenshot:

• Session recall → Hermes retrieves any past conversation by date, without spending a token to look. The memory layer that makes everything else stack up.

• /background + Kanban auto-decompose → many tasks in parallel from one agent. The multi-agent rig you used to need is gone.

• cua-driver desktop control → any model you’ve already got drives any machine you’ve already got. Tailscale on every device turns your phone into the remote.

• Reach across 22 platforms → SuperGrok OAuth, native X search, pluggable video, Microsoft Teams + LINE + SimpleX. Fewer logins. Fewer keys. Same agent.

• Twelve P0 closures + 180x faster browser → security floor and speed floor that, together, let regulated-industry teams stop holding the agent at arm’s length.

Five upgrades. One Sunday afternoon update. Zero new accounts. One of mine cancelled.

The takeaway

What landed on May 16 isn’t a feature drop — it’s the version where twelve months of accumulated work finally clicks into one coherent architecture. Memory that holds. Concurrency without orchestration. Desktop control unbound from a single model. Cross-platform presence. A security posture good enough for real work.

The agent you message tomorrow can do things it couldn’t do four weeks ago. That’s all this dispatch is saying. What to actually do with it — six deep workflows and fifty more community examples — comes Saturday.

What’s coming up

This Saturday I’m dropping the reference piece — “Everyone Should Be Using Hermes More — 50 Ways People Are Actually Using It.”

Six deep workflows I personally run every week — every one with the prompt, the screenshot, and the industry-by-industry payoff. Then fifty more short ones, sourced directly from the Hermes community user-stories docs, grouped by category so you can scan to the section that fits your week.

The math at the bottom: $25 a month, six workflows, fifty more, the equivalent of a $120K/year ops hire that breaks even by the second Tuesday.

This is the piece you’ll bookmark and pull up six months from now when a new use case comes up in your work and you want to know whether Hermes can already do it. The Hermes user-stories page lists 237 — I picked the 50 every knowledge worker should see first.

Subscribe so it lands in your inbox Saturday morning — one email, no other sends that day, archive everything you’ve read so far, leave anytime in two clicks.

If you can’t subscribe yet, hit reply with which of the five upgrades hits hardest for your work. Most common answer this week has been multitasking. My own bet for highest knowledge-worker ROI is desktop control. The reply ask is the lighter version of the subscribe — it costs nothing and tells me what to write more of.

If you want help building any of the five into your actual business — startup, wholesale, real estate, insurance, law — reply with what you’re trying to wire up. That’s the work I take on.

— John

The briefing that didn’t arrive

Monday. 6:14am.

Your phone is silent.

Your Hermes worked perfectly all week. The briefing was supposed to land in your Telegram before the alarm went off. Same five-line format you set up nine weeks ago. Same delivery time. Same chat.

7:30am. Still nothing.

You open the laptop. Hermes is sitting there, exactly where you left it, blinking back at you like nothing happened. The script ran. The model returned. The message just never went anywhere.

Here’s the catch. It wasn’t a bug. It wasn’t a model outage. It was one line of code you didn’t run on Day 1.

Nine weeks of compounding memory, dozens of skills the agent wrote for itself, your standing brief — all of it benched by a missing command.

This piece is about

1. The 20-minute install that stops it from happening

2. The one line nobody mentions in the tutorials

3. The GitHub backup that protects what the agent has learned about you

4. Six rules I wish someone had handed me on the way in.

By the end, you’ll have a working Hermes in your pocket. Not someday. Today.

For people who’ve never opened a terminal

If you’ve never opened a terminal — this article is for you. Not the future version of you who finally learns to code. The version reading this in pajamas, on a Tuesday, with a half-finished coffee.

You don’t need to be a developer. You don’t need to memorize syntax. You need to know roughly five commands. Hermes handles everything else, and when something does break, the agent itself will walk you through the fix.

One small disclaimer before we start. Every time a new technical word shows up in this piece, I drop a one-sentence demystifier in parentheses. If you already know what a VPS is, skim past those asides — they’re not for you. If you don’t, they’re the whole point.

Total time investment: 20 minutes for the install. Roughly 15 minutes a month after that.

The 30-second cost math

Three numbers tell the whole story.

$5 a month for a virtual private server (a small computer you rent in the cloud). $20 a month for the AI subscription you probably already pay for. $0 for Hermes itself — it’s open-source.

Here’s the comparison nobody writes out. An executive assistant who could prep your back-to-back meetings before you walked in, surface the doc your manager just dropped in shared drive, flag the Slack threads you missed overnight, and clean up your calendar before Monday — that hire costs about $4,000 a month. Hermes runs that same workload for $25.

The break-even is the first Wednesday.

Don’t pay for any of those yet? NVIDIA’s free tier hosts 150+ open-weight models with no credit card. We’ll wire it up in the install.

The three install paths

The install command is the same on every path. Where you type it is the decision. Three honest options, and each one answers a different version of “what happens at 6am Sunday when your laptop is closed?”

Path 1 — Run it on your laptop.

Fastest install on this list. One command in the terminal does the whole thing:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

The installer detects your platform (Mac, Linux, or WSL2), installs Python, Node.js, ripgrep, and ffmpeg, clones the repo, sets up a virtual environment, and registers the global hermes command. Five minutes, no infrastructure to provision, no credit card required. By the time it finishes you’re ready to chat.

The catch is the one this whole article exists to fix: when your laptop sleeps, your agent sleeps. The Sunday briefing waits until you wake the laptop back up. Path 1 is the fastest way to try Hermes. It can’t be the way you run Hermes 24/7. If you’re kicking the tires this week, start here. If you want the compounding value, you’ll graduate to Path 3 within a week anyway.

Path 2 — Run it on an always-on machine.

An old Mac mini in your closet. A spare desktop running 24/7. If you already have one and don’t mind it being your home server, this works. The catch is the same as your home Wi-Fi router. Power outage, internet hiccup, family member unplugging the wrong cable — and your agent is gone until you notice.

Path 3 — Run it on a $8.99/month VPS.

A virtual private server (a small computer in the cloud, rented from a hosting provider) hums along 24/7 in a data center somewhere with redundant power and proper networking. Your agent survives your closed laptop, your power outage, your flight to a conference. This is the path operators actually use.

My recommendation: Path 3. The rest of this article walks through it in full. Paths 1 and 2 use the same install command — the only difference is where you type it.

The actual install

Step 1 — Spin up a VPS

Use Hostinger. They ship Hermes as a one-click Docker image — a sealed room inside the VPS where the agent runs without touching anything else on the server. No SSH gymnastics. No manual config. You click a button and a working server appears.

Inside Hostinger, pick the KVM 2 plan. Pick a server location near you. Pick Ubuntu 24.04 LTS as the operating system. Tick the free malware scanner. Set a strong root password and save it somewhere you’ll actually find again in six months.

A VPS, again in plain English: a small Linux computer that exists in a data center, that you control from your laptop. You’ll never sit in front of it physically. You’ll talk to it through a web dashboard for setup, then mostly forget it exists.

While the VPS provisions (90 seconds), open a new password manager entry called “Hermes.” Save everything that comes next there. Future-you will be grateful.

Step 2 — One-click install Hermes

Once the VPS is alive, you have two ways to put Hermes on it. Both work. They’re different on the inside, and the difference matters more than this article let on.

Option A — Install Hermes directly on the VPS root. You SSH in (open a terminal, log into the server, type commands), run the official installer, and Hermes drops its files straight into the server’s main filesystem. Hermes app code lives in /opt/hermes. Your settings, API keys, skills, and memory live in /opt/data. The service runs at the root level. Nothing sits between Hermes and the operating system. This is the manual path — closer to how a developer would install any other app on a Linux box.

Where it wins: full control, no extra layer between you and the agent, easier to debug at the OS level if something goes sideways.

Where it loses: one machine, one Hermes.

If you ever want a second agent (a sales Hermes, a research Hermes, a personal Hermes), they share the same files, the same API keys, and the same memory.

Splitting them later means re-installing from scratch. You also lose the safety net of containerization — when Hermes updates or a dependency breaks, it can take other things on your VPS with it.

Option B — Use the one-click Docker image. Hostinger ships Hermes as a Docker template (a sealed box on top of the VPS, with its own files, its own settings, and its own copy of everything it needs). You don’t SSH. You don’t install dependencies. You click Deploy in the dashboard and 60 seconds later Hermes is running inside its own container. Your settings and memory still live in a folder you can reach (/docker/hermes-agent-xxxx/data), but the agent itself stays sealed.

Where it wins: fast (under two minutes start to chat), reproducible (the container is identical for everyone who installs it), upgradeable (Hostinger swaps in a new image without breaking your data), and — most important — scalable. When you want a second Hermes, you deploy a second container next to the first. Each one is its own sealed room: its own keys, its own memory, its own crashes. The wholesale Hermes can’t break the personal Hermes.

Where it loses: one extra layer between you and the OS. If you ever need to do something exotic at the system level, you’re reaching through Docker to do it.

My pick: Option B for ~95% of readers. The Docker container is the right default unless you already know exactly why you want root-level install. Two reasons that decide it: future-proofing for multi-agent (Article 6 covers this; you’ll thank yourself in month three), and the fact that Hostinger’s one-click flow eliminates every place you’d otherwise get stuck. The rest of this walkthrough uses Option B.

Here’s the actual install. In Hostinger’s dashboard, open Docker Manager. Hit Compose, then One-Click Deploy. Search “Hermes.” Hit Select.

You’ll set an admin username and admin password for the Hermes instance. Save both in the password manager entry you created in Step 1 — you’ll need them in 30 seconds.

Hit Deploy. The container spins up in roughly two minutes.

Behind the scenes: Hostinger pulls the official Hermes Docker image, starts it in its own isolated container, and exposes a web dashboard you’ll use for the rest of the setup. You will not type a single Linux command on this path. The terminal stays closed.

When the dashboard says the container is running, hit Open. You’ll see a login screen. Use the admin username and password you just set.

Step 3 — Run the setup wizard and pick your model

You’re now inside Hermes’s setup wizard. The wizard is interactive — it walks you through every choice with arrow keys and the space bar. No syntax to learn.

First decision: your model. Hermes runs on any provider — Anthropic, OpenAI, Google, NVIDIA’s free tier, or a local model on your own hardware.

Here’s the rule that collapses the decision:

use the AI subscription you already pay for.

If you pay for ChatGPT Pro, pick OpenAI Codex — it lets Hermes use your existing subscription instead of burning API credits. If you pay for Claude, pick Anthropic. If you pay for Gemini Advanced, pick Google. If you pay for none of the above, pick NVIDIA NIM — their free tier hosts 100+ open-weight models with no credit card and no daily token cap.

Authenticate when prompted. The wizard shows you a code. Paste the code into the provider’s auth page in your browser. Come back to the dashboard. You’re in.

Pick the strongest model your provider offers. GPT-5.4, Claude Sonnet 4.6, and Gemini 3.1 Pro all work. Optimize for cost earlier on — you might burn a lot of tokens if you are building apps or running corn jobs daily, then swap models later if you need to.

Step 4 — Connect Telegram

Telegram is the lowest-friction option — no developer accounts, no app approvals, two minutes to a working bot. Pick it first. Add Slack, WhatsApp, Discord, or Signal later when you know what you want each one for.

In the wizard, hit the space bar on Telegram. Hit Enter. The wizard asks for a Telegram bot token.

Open Telegram on your phone. Search for BotFather — the blue-check official bot from Telegram itself. Send /newbot. Pick a display name (anything you want — Atlas, Hermes, Briefing, whatever). Pick a username ending in _bot.

BotFather replies with a bot token (a long string starting with numbers and a colon). Copy it. Paste it into the Hermes wizard. Hit Enter.

The wizard then asks for allowed user IDs. This restricts your bot so only you can message it. To find your own Telegram ID, message @userinfobot on Telegram and send /start. It replies with your numeric ID. Paste that into Hermes. Confirm yes when asked if this is your “home channel.”

Open your new bot in Telegram. Send hello. The bot replies.

You now have a working AI agent. We’re roughly 12 minutes in.

The one line everyone skips

This is the section the title promised — with one twist that depends on which path you picked.

The gateway is the background process that listens for incoming messages, routes them to your agent, and keeps your Telegram bot reachable. Without it running, your phone goes silent. The Sunday briefing waits. The whole point of a 24/7 agent collapses.

Here’s where the path matters.

If you picked Path 1 (laptop) or root-install on a VPS: the gateway only runs while the terminal session that started it stays open. Close the terminal, restart the machine, lose the SSH connection — the gateway dies. The fix is one command:

hermes gateway install

That command registers the gateway as a system service. It auto-restarts on reboot. It survives crashes. It keeps running even when nobody is “watching” it. Two seconds to run. Almost nobody runs it on Day 1. This is the line everyone skips.

If you picked Path 3 (Hostinger one-click Docker — what this walkthrough used): good news. Run hermes gateway install anyway as a sanity check. You’ll see something like this:

“No service install needed in this Docker container. The container runtime is the service manager — use Docker restart policies instead.”

That message means Hostinger’s container is already doing the job. The Docker layer wraps Hermes in a process that auto-restarts on crash, survives the VPS rebooting, and stays alive even when you close your laptop. The reason Docker is the recommended path is exactly this — the line everyone skips is the line you don’t have to run.

Either way, verify it. Run hermes gateway status. You should see:

“✓ Gateway is already running.”

If you don’t, you’re in the small percentage of installs where something didn’t auto-start. Ask Hermes itself to walk you through the fix — paste the error into your Telegram chat and it’ll diagnose its own gateway. (This is the kind of self-repair the agent gets sharper at over time.)

What’s already running out of the box

While you’re checking gateway status, scan what Hermes ships with on Day 1. Most install guides skip this part — they show you how to start the agent and stop there. Hermes arrives with more than an empty shell.

The skills library. Hermes ships with ~85 built-in skills the first time you launch it. Procedures the agent can pull off the shelf for common jobs — web search, file editing, calendar parsing, document drafting, image generation, terminal commands, browser automation, vision (reading screenshots and images), text-to-speech, memory management. You don’t have to write a skill for those workflows; they’re already there.

Pre-installed profiles. If you imported a config or installed the official agent packs, you’ll see profiles already active when you run hermes gateway status. In the install I’m pulling from for this article, three were already on by default: an atlas-designer (visual artifact generation), an echo-repurposer (turning a single piece of content into threads, posts, and notes), and a quill-writer (long-form drafting in a specific voice). Yours may vary. The lesson is the same — run hermes profiles list and see what’s loaded before you start building new agents from scratch.

The Curator. A background maintenance system that runs every seven days, marks unused skills stale after 30 days, archives them after 90, and consolidates overlapping ones. It’s the reason the self-improving loop doesn’t turn into hoarding. You don’t have to set it up. It’s already watching.

The self-improving loop itself. Every 10–15 tool calls, the agent reviews what worked in the session and rewrites the relevant skill file. By week six your skills look different than they did on Day 1. You don’t manage it. It manages itself.

The takeaway: Hermes isn’t a blank chat window pretending to be an agent. It’s a runtime with memory, skills, a personality file, a scheduler, and a maintenance system — all on from minute one. Your job in week one is mostly to use it and let the loop do its work.

The GitHub backup that saves the compounding part

Hermes gets sharper every week because of three folders: memory, skills, and soul. Memory is what the agent knows about you and your work. Skills are the procedures it’s written for itself. Soul is its personality and rules of engagement. Lose any of those folders and you lose months of compounding work.

The fix is a nightly GitHub backup.

Open GitHub (https://github.com/settings/tokens). Create a classic personal access token (a long string of characters that lets a script act on your account, like a password but scoped) with repo permission. Copy it.

Here’s the rule almost everyone breaks: never paste an API key or token into the chat. Not into Telegram. Not into the Hermes web dashboard’s main chat window. Tokens in chats end up in logs, in conversation history, in backups, in places you didn’t expect.

Use this instead, in the terminal (or in the dashboard’s terminal-equivalent panel):

read -rsp "Paste GitHub token: " GITHUB_TOKEN; echo; printf '\nGITHUB_TOKEN=%s\n' "$GITHUB_TOKEN" >> /opt/data/.env; unset 
GITHUB_TOKEN
hermes gateway restart 

That one-liner hides the token while you paste it (so it never lands in your terminal scrollback or the chat), appends it to /opt/data/.env — the env file your Docker Hermes reads at startup — and immediately clears the variable from your shell. Then hermes gateway restart makes the agent reload with the new token live. Safe. Repeatable.

Then ask Hermes itself, in plain English: “Create a private GitHub repo called hermes-backup. Set up a nightly cron at midnight my time that commits any changes in my memory, skills, and soul folders to that repo.”

The agent does it. The cron runs. Every night, the compounding part of your work gets a versioned snapshot.

If the VPS ever dies, you spin up a new one in 15 minutes and re-clone the repo. Zero memory loss.

Your first five minutes with Hermes

You have a working agent. Now you need three prompts that turn “it works” into “it’s useful.”

Prompt 1 — the tool inventory. Send this to your bot:

 “What tools do you have available? List each one and tell me what it’s best for.

Hermes replies with a one-paragraph map of what your new agent can actually do — web search, file editing, scheduled jobs, memory, the model you picked, the gateway you just installed. Pin the reply. It’s your menu.

Prompt 2 — the standing brief. Send this next:

“My name is [your name]. I run [your work, in one sentence]. I want you to be my 24/7 assistant. Ask me 10 questions you’d need answered to do that job well, then save the answers to your memory.” 

The agent will interview you. It writes the answers into your memory file. That file loads at the start of every conversation forever after.

Prompt 3 — your first cron. Send this last:

“Every Monday at 6am my time, send me a 5-line briefing on the three things I should know about my work this week. Generate one sample briefing now so I can see the format and adjust it.” 

Hermes drafts the sample, you tweak it once, and the cron schedules itself.

That’s the whole on-ramp. Twelve minutes for the install. Five minutes for the first prompts. By the time you close the laptop tonight, you have an agent that knows who you are, what you do, and when to show up.

The five rules I wish someone had handed me

Each rule takes 30 seconds today. Each one prevents a specific bad day I’ve already had. Run through them.

Rule 1 — Tokens go in config, never in chat. Use the hidden-input one-liner from the GitHub backup section (read -rsp ... >> /opt/data/.env) for every credential the agent ever asks for, then hermes gateway restart. The chat is logged. The env file isn’t. The terminal scrollback isn’t either.

Rule 2 — Run hermes gateway install on Day 1. I already said this twice. I’m saying it a third time because it is the single most-skipped command in the whole install. Without it, the briefings you schedule today won’t survive the first reboot.

Rule 3 — Back up to GitHub nightly. Memory, skills, soul. The compounding folders. If the VPS evaporates, those three folders are the only thing that brings the agent back to where it was last week.

Rule 4 — One Hermes per Docker container. Even if you’re only running one agent today, install it in its own container with its own scoped keys. Article 6 covers the multi-agent split — but starting clean costs nothing on Day 1 and saves a painful migration in month three.

Rule 5 — Lock down the VPS. Set up a firewall (ufw on Ubuntu — it ships free, takes 5 minutes to configure). Restrict SSH (the way you log in to your VPS from your laptop) to your IP. Rotate keys monthly. If any of those words feel unfamiliar, that’s fine — ask Hermes itself to walk you through the setup, and have Claude Code review the config. Article 6 covers the deep version.

Together: about 15 minutes of one-time setup. The next six months of “wait, why is this happening” — avoided.

What this looks like for an operator who’s never opened a terminal

Same install. Same five commands. Four different briefings on Monday at 6am. I’ve watched these four readers go through this exact setup over the last year — a wholesale distributor, a residential real estate broker, a law firm partner, and a senior PM at a Series B SaaS company. None of them opened a terminal after Day 1. Here’s what their Hermes does for them.

The Monday 6am briefing changes by who’s reading it. Same Hermes, same cron, same five-line format. Different signal.

• A wholesale distributor gets three supplier price changes that hit overnight, two SKUs whose inventory is moving faster than normal, and one customer whose order pattern looks off.

• A residential real estate broker gets new listings in three target neighborhoods, two price drops flagged, and a heads-up that Thursday’s showing has been rescheduled.

• A law firm partner gets one filing deadline inside the next 72 hours, two opposing counsels who emailed after 9pm, and one client whose retainer is 60% drawn down.

• A senior PM at a Series B SaaS company gets three Linear tickets that flipped to “blocked” since Friday, one Slack thread they were tagged in but missed, and one design review on tomorrow’s calendar that still has no Figma link attached.

The Friday counterparty dossier changes the same way.

Hermes scans every name in your inbound emails for the week — buyers, sellers, agents, suppliers, opposing counsels, recruiters, stakeholders — and ships a one-paragraph context dump on each. Public news, recent press, prior interactions, the signal you actually need.

The wholesale distributor learns one supplier just got acquired. The real estate broker learns one buyer agent has closed three deals in their target zip code this quarter. The law firm partner learns one opposing counsel has a flagged prior case. The PM learns the recruiter who DM’d them on Tuesday recruited their old skip-level two years ago.

The Sunday plan converges them all back to the same shape. Three highest-leverage moves for Monday. One sentence each. The wholesale distributor gets three supplier conversations to schedule. The broker gets three sellers to call. The law firm partner gets three motions to advance. The PM gets three stakeholder asks to front-load into Monday standup, with a one-line script for each.

Now — the moment.

Saturday morning. You’re at a kid’s soccer game, or a brunch, or your favorite coffee shop on a side-project run. Your phone buzzes. Something inbound. A buyer, a client, a recruiter, a supplier — somebody wants something.

By the time you’ve pulled up the message, your Hermes has already surfaced the context. Who the person is. What they last asked you. The relevant comp, contract, motion, or PRD. A draft reply.

You read it in 90 seconds. You tweak two lines. You send it from the bleachers.

The version of you without Hermes opens the message, files it under “Monday,” and replies three days later with something generic. The version of you with Hermes replies in four minutes with something that sounds like you’ve already done your homework. Because you have. The agent did it Saturday morning before you’d finished your coffee.

None of these four people learned the terminal. They learned five commands. Hermes does the rest.

Quick Recap

If you followed along, walk away from this article with:

• A working Hermes running in its own Docker container on a $5/month VPS

• A Telegram bot you can message from your phone, locked to your user ID

• A model provider connected via hermes config set, never via the chat

• A gateway service that auto-restarts on reboot — because you ran hermes gateway install on Day 1

• A nightly GitHub backup of your memory, skills, and soul folders

• A standing brief saved in memory, plus one working cron scheduled for next Monday at 6am

You wrote zero lines of code. You typed roughly five terminal commands. You’re 20 minutes in.

The next time you open Telegram, you’ll have an employee who’s been working on your weekend while you weren’t.

Where this series goes next

Today: the install, the line everyone skips, and a working Hermes in your pocket. Next Sunday: Article 3 takes you inside how Hermes actually thinks — the mental model that turns this from “a chatbot I installed” into a teammate you can diagnose, tune, and trust.

Subscribe so it lands in your inbox Sunday.

1. The AI Agent That Keeps Working After You Close the Laptop Why 100,000 builders quietly switched in seven weeks — and the architecture shift that makes it compound. (We are here)

2. Hermes in 20 Minutes — The Install Guide for People Who've Never Opened a Terminal

3. The Five Pillars in Depth — How to Diagnose Your AI When It Misbehaves

4. Three Hermes Setups That Pay for Themselves in Week One

5. Hermes vs ChatGPT Tasks vs Claude Code vs OpenClaw — The Honest Comparison

6. From One Agent to an Army — How to Split Hermes Into a Real Team

Picture this

Monday. 6:14am. Your phone lights up before your alarm goes off.

It’s a Telegram message from a bot you set up nine weeks ago and haven’t touched since. Five lines.

“Top three priorities this week. The Claude Design competitor that launched Friday is pulling traffic — pricing page seems to be the magnet. Two warm leads went cold last week, both opened your follow-up. Your Substack thread from Wednesday is the highest-engagement piece you’ve shipped in three months — start of a series? Calendar: two conflicts on Thursday you haven’t seen.”

You didn’t ask for this briefing this morning. You set it up once. It has arrived every Monday since.

Here’s the part that messes with your head. The first briefing, back in March, was generic. Same prompt, same structure, but the content was bland. It led with calendar items that weren’t urgent. It surfaced metrics you didn’t care about. By April, you stopped reading the second half.

Today’s briefing — week nine — is sharp. It knows which lead actually matter to you as well as what post has the highest engagement. It learned that you read the priorities section first because you’re at the kitchen counter making coffee. It quietly stopped surfacing the metrics you ignored.

Nobody updated it. You haven’t even opened the chat in seven weeks.

That’s the gap I want to show you today. Every AI tool you use stops thinking the moment you stop typing. The one I’m about to introduce gets better while you sleep — and it’s the reason 100,000 builders just switched in seven weeks.

Today I’m breaking down what it is, why the architecture matters, and the five-pillar mental model that makes the whole thing click.

If you’re a founder, an indie builder, a designer running solo, or a tech operator with too much on your plate and not enough hours — this is for you.

Every AI tool you use is an intern who quits at 6pm

Open Claude. Paste in your product positioning doc. Ask for a landing page critique. Get back something useful. Close the tab.

Open it tomorrow to draft a cold outreach email to a potential design partner. The same Claude that just gave you a sharp critique of your hero section now has no idea what your product does, who you’re selling to, or that you decided last week to stop targeting agencies and focus on solo founders. You paste the positioning doc again. You explain the ICP again. You re-state the constraints again.

You do this every time you open a new chat. Tuesday with Claude. Wednesday with ChatGPT for a different task. Thursday with Cursor for a coding session.

Each tool starts from zero. Each conversation begins with the same setup tax.

Custom instructions help. Projects help. The new memory features help. They all share one limit — the prompts you wrote are static. The output in week 50 is the same shape as the output in week 1. The tool produces. It doesn’t compound.

Here’s the thing nobody talks about. Your AI usage isn’t constrained by the model. GPT-4.7 is plenty smart. Claude Opus is plenty smart. The constraint is the interface. You’re treating the smartest pattern-matcher ever built like a slot machine — pull the lever, get an answer, walk away. The smart move is to treat it like a new hire. Train it once. Watch it get sharper every week. Wake up to its work instead of starting it.

That’s the gap. That’s what Hermes solves.

Why this isn’t just another AI tool

Hermes Agent crossed 140,000 GitHub stars in seven weeks. Faster than LangChain. Faster than AutoGPT. Faster than any agent framework anyone’s tracked.

NVIDIA built a fork on top of it inside three weeks of launch. Nemo Claw — same engine, enterprise wrapper, now shipping inside Fortune 500 deployments. That doesn’t happen unless the architecture is doing something genuinely new.

But the timing of the surge had a more specific reason. In January 2026, an independent security audit pulled apart OpenClaw — the agent most developers had been running. The audit found 512 vulnerabilities. 341 of the skills in the public hub were flagged as malicious. One of the vulnerabilities let an attacker take full control of your machine through a single link.

Developers migrated. Fast. That explains the spike in the GitHub graph.

What it doesn’t explain is why people stayed. Security migrations are usually temporary — devs move because they have to, then move back when the original tool patches the issues. OpenClaw patched. Hermes kept growing.

So I spent a month figuring out what was actually different. Not the marketing pitch. Not the comparison table. The actual architecture decisions that make Hermes feel like something else entirely.

Here’s the short version. Hermes is built around five separate systems that work together — Memory, Skills, Soul, Crons, and a Self-Improving Loop. I’ll call them the Five Pillars for the rest of this piece. Every other AI tool has some of these. None has all five. And the way they compose is what makes the whole thing compound.

Let me show you what I mean.

The Five Pillars — how Hermes actually thinks

Hermes is open-source. You install it on your laptop, a Mac mini, or a five-dollar virtual private server. Once it’s running, you talk to it through whatever messaging app you already live in — Telegram, WhatsApp, Slack, Discord, iMessage. The agent lives in your pocket, not in a browser tab.

Underneath, you pick which model it runs on. Claude, GPT, Gemini, or a local model on your own hardware. One config change and the same agent runs on a different brain. That matters more than it sounds — when your provider rate-limits you mid-launch, you have a fallback. When a cheaper model is good enough, you save the money.

But the interface and the model aren’t what makes Hermes different. The Five Pillars are.

Pillar 1 — Memory

Two files do the heavy lifting. USER.md (1,375 characters) holds you — your name, your tone preferences, your timezone, the things you’ve told the agent never to do. MEMORY.md (2,200 characters) holds the work — your projects, your stack, your conventions, the lessons learned from last week’s session.

Both files load as a frozen snapshot at the start of every conversation. The agent doesn’t wake up stateless. It wakes up knowing you ship in TypeScript, that you cut your last design partner two weeks ago, and that you hate em-dashes in body copy.

The character limits are the feature, not the bug. When either file hits roughly 80% capacity, the agent consolidates — merging related notes into denser versions until only the load-bearing facts remain. No bloat, no rambling diary, no 8,000-line context dump quietly eating your tokens.

What you save and what you skip matters. Save preferences and durable facts — “I prefer TypeScript over JavaScript,” “this server runs Postgres 16,” “project uses tabs and 120-char lines.” Skip secrets and ephemeral state — “the renewal call is at 3pm Thursday” is a calendar item, not a memory entry. Hermes auto-saves what it learns, but you can also just tell it — “remember that” or “chuck this in memory” — and it does. For old conversations, the agent searches your full session history (stored locally in SQLite) on demand. Critical facts live in memory. Everything else is searchable when you need it.

Pillar 2 — Skills

Skills are markdown files that hold procedures, not facts.

Think of it as the difference between knowing a recipe exists and being able to cook from memory. If I ask you to make pancakes from memory, you’ll wing it differently every time. If I hand you the recipe, you produce the same pancakes every time. Skills are the recipes.

A Hermes skill is three things — a name, a short trigger description telling the agent when to pull it off the shelf, and a numbered procedure. Could be “draft the weekly investor update.” Could be “triage Monday inbox.” Could be “prep notes before a sales call.” Whatever you do enough times that you wish someone else handled it.

The interesting part — the agent writes most of its own skills and analyzes your conversation and proactively turns those repeated patterns into skills. When you correct it on the spot, it remembers what worked. When it solves a hard problem after five or six attempts, it saves the working approach to a new skill file. Next time you ask for something similar, it follows the playbook instead of rediscovering the procedure.

Pillar 3 — Soul

A single file called SOUL.md shapes the agent’s personality.

You write it once. It loads slot one in the system prompt, before anything else. Tone, communication style, hard limits, things you want the agent to never do.

This matters more than it sounds. Spin up four Hermes agents and each one has its own voice. My Scout is sharp and headline-driven for morning competitive briefings. Quill is patient and voice-matched for Substack drafting. Atlas is opinionated about brand and refuses to ship generic AI imagery. Echo is built for scroll-stop on X. Same model underneath. Four teammates. Same setup works for a life strategist, a meeting-prep agent, a client-comms agent, a coding pair — pick the roles, write four souls, run four bots.

I’ll show you my actual SOUL.md files in Article 3. For now, the point is — without an identity layer, every AI you use is the same AI wearing different hats. With one, you have a team.

Pillar 4 — Crons

This is where Hermes leaves ChatGPT or Claude in the dust.

You tell the agent, in plain English, “every Monday at 6am, brief me on what’s the most important thing to focus on” It schedules itself. Every Monday at 6am, a fresh session spins up, runs the task, sends the result to your Telegram, and disappears. Survives restarts. Handles time zones. No cron syntax to learn.

ChatGPT Tasks can technically do this. But the prompt never improves. The procedure underneath is frozen. Hermes runs a scheduled employee, not a scheduled prompt. Which brings us to the pillar that actually makes the whole thing work.

Pillar 5 — The Self-Improving Loop (and the Curator that keeps it honest)

Every ten to fifteen tool calls, the agent pauses, looks at what worked in the session, and rewrites the relevant skill file.

That sentence sounds boring. It’s the whole point.

My meeting prep skill from week one isn’t the skill running today. The agent rewrote it four times. Once because I corrected which background context actually mattered. Once because it found a faster path to the relevant Slack history. Once because it consolidated “pull notes” and “draft agenda” into one step. Once because it noticed I always asked the same follow-up — what’s the one decision I need to make here — and started leading with that.

Same prompt. Same delivery time. Same Telegram channel. Different procedure underneath every two weeks.

But here’s the catch nobody talks about. A self-improving loop without garbage collection is just a hoarder. Without something pruning the back of the cabinet, your agent ends up with 47 overlapping skills — three different “prep for meeting” procedures, two outdated “sort inbox” playbooks, a skill from week three that hasn’t fired since week three. Every one of them sits in the agent’s context. Every one of them costs tokens. The loop becomes the bloat.

This is where the Curator comes in.

It’s a background maintenance system that runs every seven days.

Skills you haven’t used in 30 days get marked stale. Skills you haven’t used in 90 days get archived to a recoverable folder — never auto-deleted, just out of the way. The Curator also reviews active skills and asks itself: are any of these doing the same job? Should two be consolidated into one? Is this version actually better than the last one?

You can check it any time. One command — hermes curator status — shows you exactly what’s stale, what’s been archived, when the last run was, and how the next run is scheduled. It’s the boring infrastructure piece that makes the self-improving loop actually compound instead of slowly collapsing under its own weight.

The Curator never touches skills you wrote by hand or installed from the official hub. Only the agent-authored ones. That distinction matters — your custom work is protected. The loop only gets to clean up after itself.

That’s the compounding system. The agent writes its own skills. The Curator keeps the library lean. The combination is the thing every other AI tool is structurally incapable of doing. And once you see it work — even once — you stop being able to go back.

Where Hermes fits in your stack (and where it doesn’t)

Every reader who got this far is silently asking the same four questions. Let me knock them out.

Isn’t this just ChatGPT Tasks? ChatGPT Tasks runs a prompt on a schedule. Hermes runs an employee on a schedule. The prompt in ChatGPT Tasks never improves between runs. The procedure never gets sharper. And ChatGPT Tasks lives inside ChatGPT — if you want it to reach you in WhatsApp, Slack, or Telegram, you wire that up yourself. Hermes is built around the idea that the value compounds the longer it runs. That’s the difference and it’s the whole difference.

Isn’t this just Claude Code? Claude Code is the AI you sit and drive at your desk. Coding, deep knowledge work, focused execution — Claude Code wins. Hermes is the AI in your pocket when you’re walking the dog or sitting in an airport. Different surface, different job. Most operators end up running both — Claude Code at the laptop, Hermes everywhere else. They can even share the same underlying brain. Hermes can call Claude as its model.

Then why not just use Claude Code for everything? Two reasons.

First — uptime. Claude.ai sat at roughly 98.66% uptime over the last 90 days, with 137 logged incidents and a median outage length over an hour. If your morning briefing depends on Claude being up, you’ve outsourced a critical workflow to a single point of failure. Hermes runs model-agnostic — when Claude is down, you flip one config and run on GPT or Gemini. Same skills, different brain.

Second — cost. Claude Code on Max 5x ($100/month) and Max 20x ($200/month) is gated by 5-hour prompt windows that frustrate heavy users. Codex on a ChatGPT Pro subscription ($200/month) is unlimited at the same price. Per-task, the gap is brutal — one independent test of the same coding task burned 6.23M tokens on Claude and 1.5M on Codex, working out to roughly $93 versus $7.50 on pay-as-you-go pricing. If Claude is your only horse, you’re paying premium prices for a horse that occasionally falls down. Hermes lets you ride whichever horse is fastest that day.

Isn’t Hermes less secure than Claude Code or Codex? This one’s honest — yes. Claude Code and Codex run inside Anthropic’s and OpenAI’s hardened infrastructure.

Your API keys, your conversation history, your tool calls — all wrapped in their enterprise security model. Hermes runs on your own machine, your own VPS, your own Docker container. That’s a feature for IP protection (your data never leaves your hardware) but it’s a liability if you don’t set it up right.

You need to lock down your VPS firewall, restrict SSH access to your IP, set scoped API keys per agent, encrypt secrets in the .env file, and run a nightly security audit. It’s not hard, but it’s not free either — figure on an extra hour during setup and 15 minutes a month of maintenance. The trade-off: your data stays yours, but you become your own security team.

Isn’t this just n8n or Zapier with AI nodes? n8n and Zapier are deterministic workflow tools. They’re great at “when X happens, do Y.” They have no memory, no reasoning, no skills that improve. Hermes does reasoning and deterministic execution. Most operators end up with three layers — Claude Code at the desk, Hermes in the pocket, n8n for the deterministic plumbing in between. No overlap. Different jobs.

Isn’t this just OpenClaw? Was. Before January. After the security audit, the comparison stopped being apples-to-apples. The community framing I keep hearing — and it’s accurate — is that OpenClaw packages an agent around a messaging gateway. Hermes packages a gateway around a learning agent. Inverted architecture. Different outcome.

Because Hermes lives inside Telegram, Discord, WhatsApp, and Signal, you can voice-message your agent the way you’d voice-message a friend. Walking the dog at 6am and want to brain-dump three ideas before they evaporate? Hit record, hit send. The agent transcribes, files the ideas to the right project, and pings you back when you’re at the laptop. ChatGPT can do voice — but only inside ChatGPT, only when you remember to open it. Claude Code is keyboard-only. n8n doesn’t even pretend. Voice-in, text-out, asynchronous, cross-channel — that’s the use case Hermes owns alone.

Here’s the bigger picture though. The mistake every comparison piece makes is treating these as substitutes. They’re not. They’re layers. You pick the right one for the surface — desk versus pocket versus integration plumbing — and let them work together.

Proof in my own numbers

Take that meeting prep skill from Pillar 5. Week one — 22 minutes from “prep me for the 3pm” to a useful brief in my Telegram. Week six — 8 minutes. Same prompt. Same delivery format. Same chat.

I never told it to be faster. The skill rewrote itself four times. By week six it was leading with the one decision I need to make before I’d even asked — because it noticed me asking that follow-up three weeks in a row.

That’s the loop. You don’t manage it. It manages itself.

Three scenes from my actual week

This is where the abstract gets concrete. Let me walk you through three moments from my own week as a founder and designer running solo. The kind of week most of you reading this are living through right now.

Monday, 6am. My phone buzzes twice. Scout, my research agent, drops two briefings — back to back, before I’ve opened a tab.

The first is the top-5 AI news scan. Five stories ranked by relevance to my work, each one structured the same way — what happened, why it matters to me specifically, the non-obvious read, viral score, source links. This morning it led with Anthropic shipping a legal workflow suite and OpenAI launching Codex inside the ChatGPT mobile app. I would’ve stumbled across both of those by Wednesday. Scout had them in my hands before coffee.

The second is the competitor inspiration scan. What Aakash, Lenny, Nate Herk, Anna Marie shipped this week — with a “John’s sharper angle” line for each one telling me where the gap is. This morning it surfaced Aakash turning Claude Skills into a testing framework, with the angle: translate “skills” out of developer language and into operator language — reusable SOPs for real estate intake, wholesale quoting, insurance claims triage. That’s the next piece I’m writing. Scout found it for me while I was asleep.

I read both in 90 seconds, standing at the kitchen counter. Doing this manually would’ve been 45 minutes of doomscrolling X, Substack, and Hacker News every morning. I wouldn’t have done it manually. That’s the whole point.

Tuesday, 2pm. A Benchling recruiter emails me about a Senior Product Designer role. I have my Gmail wired into Hermes — when a recruiter email lands, an automation fires.

Tuesday, 2pm. My Gmail is wired into Hermes. When a recruiter email lands, an automation fires before I’ve even read it.

By the time I open the inbox, my Telegram has a full prep packet for a Senior Product Designer role at Benchling.

• The opportunity itself — $181K-$246K base, App Foundations team, AI-workflow focus, hybrid in SF.

• Why I’m a fit, broken into three positioning angles (systems designer not just UI, Meta-scale ambiguity work, AI-as-product-workflow not feature).

• The company’s funding picture ($100M Series F, $6.1B valuation). Their two most recent launches (Benchling AI command center, Anthropic MCP partnership). A drafted recruiter reply with three lines I can paste in, plus eight sharp questions to ask back.

The version of me without Hermes opens the email, files it under “research later,” and replies three days later with something generic. The version with Hermes replies in ten minutes with something that sounds like I’ve already done my homework. Because I have. The agent did it.

Friday, 5pm. I publish a Substack piece. Echo — my repurposing agent — turns it into a 12-tweet X thread, five standalone tweets, and three Substack Notes in my voice. All ready to schedule. I spend ten minutes reviewing and tweaking. The thing that used to eat half my Saturday now happens while I’m cooking dinner.

Here’s the math nobody wants to write out. The Hermes setup running my week costs me roughly thirty dollars a month in infrastructure plus another forty in model API calls. For that, I get the equivalent of a junior researcher running competitive intel, a part-time social media manager handling repurposing, and a research analyst building dossiers on every interesting inbound. The people-cost version of that stack is north of seventy thousand dollars a year.

That’s not a “productivity boost” pitch. That’s a one-person company quietly turning into a five-person company without hiring anyone.

What I’m not telling you (that every other guide skips)

You should know five things before you set this up.

Your machine has to be on

If you run Hermes on your laptop and your laptop is closed at 6am Sunday, your Monday briefing waits until you open it. The fix is a five-dollar-a-month virtual private server. Article 2 covers exactly how. But hear me say it now — closed-laptop Hermes is the number one reason people give up on the tool in week three. Don’t be that person.

The self-improving loop is not magic.

It compounds best when you correct the agent on the spot. “That was wrong because X. Save the lesson.” If you ignore bad output instead of fixing it, the loop drifts in the wrong direction. Hermes treats your silence as approval. Don’t be silent.

Each agent needs its own SOUL.md and MEMORY.md — and you should write them with help. SOUL.md is the file that loads first in the system prompt, before anything else. Everything that comes after — the memories the agent writes, the skills it creates, the way it consolidates knowledge over time — all of it gets filtered through that identity. Skip the file or copy-paste a generic one across four agents and you end up with four versions of the same teammate. The trick I use: open Claude on the side and ask it to interview me about what each agent should be. Tone, no-go words, audience, what success looks like, what failure looks like. Twenty minutes of questioning beats forty minutes of guessing every time. The output is sharper, the agent is more personalized, and you’ll never need to rewrite it from scratch.

Auto-generated skills are a starting point, not a finished product.

When the agent writes its own skill after solving a hard problem, the procedure is usually right. The edge cases are usually wrong. Read every auto-generated skill file once before you trust it in production — especially anything that touches your inbox, your calendar, or anything client-facing. The fix is mechanical: sync your ~/.hermes/skills/ directory to a private GitHub repo and run a daily cron that commits any changes. Now you have a diff trail. You can see what the agent rewrote yesterday, roll back if it broke something, and audit what’s drifting. Article 6 covers the exact setup.

Regulated industries need extra guardrails.

Law firms, healthcare practices, regulated finance — you cannot let Hermes touch client data until you’ve thought through data residency, audit trails, and least-privilege API keys. Article 6 covers the multi-agent setup for regulated workflows specifically. Don’t skip that one if you’re in one of those industries.

What you should have now

If you’ve read this far, you should walk away with:

• A clear mental model of why most AI tools forget you and how Hermes is structurally different

• The Five Pillars as vocabulary you can use to diagnose any AI agent — yours or someone else’s

• An honest read on where Hermes wins (compounding, voice, cross-channel) and where it loses (security setup, machine uptime, the maintenance tax of doing it right)

• Three concrete scenes from a real founder’s week showing what this looks like in practice

• A working sense of where Hermes fits in your stack alongside Claude Code, ChatGPT, Codex, and n8n — and the reasons you might want all of them

The first time you set up a Monday briefing, close your laptop on Sunday night, and wake up to a Telegram message that’s sharper than anything you would’ve written yourself — you’ll understand why 100,000 builders switched in seven weeks.

Where this series goes next

Today’s piece was the mental model. The next five pieces are the hands-on guide.

Article 2 drops Tuesday. It’s the 20-minute install — even if you’ve never opened a terminal, you’ll have a working Hermes on your phone by the end of it.

Subscribe so it lands in your inbox Tuesday morning. Five more pieces coming on building your 24/7 AI operator.