Hermes Agent adds 5-pillar personal-OS setups with 136K compaction rules

• Hermes builders are converging on a shared core: memory, skills, soul files, scheduled jobs, and a feedback loop that turns repeated work into reusable procedures, according to shannholmberg's five-pillar breakdown, petergyang's episode post, and petergyang's diagram.
• The sharpest operational advice in the evidence is boring in the best way: keep one folder per agent, inject secrets through the container instead of chat, and give every agent its own accounts and scoped keys, per shannholmberg on agent folders, shannholmberg on config set, and shannholmberg on least privilege.
• Personal-OS setups are already spilling into creator work: petergyang's clip says Moritz Kremb uses cron jobs to scrape ideas, rough out scripts with AI, then hand-records the final script and auto-posts to YouTube, Instagram, and TikTok.
• Hermes looks less like a chatbot and more like a stateful automation layer when you add backups, resumable sessions, slash-command skills, webhooks, and self-patching checkpoints, as aakashgupta's feature card lays out.

You can watch Moritz Kremb's full Claude Code walkthrough, skim the newsletter version, and compare it with Aakash Gupta's 15-feature Hermes card. The oddest concrete number in the mix comes from shannholmberg on compaction, which says Hermes hits compaction around 136K tokens and pauses crons while it repairs context.

The cleanest mental model in the evidence is a five-part stack for Hermes, plus a four-part stack for Claude Code.

Hermes, per shannholmberg, is built around:

1. Memory, stored in user.md and memory.md
2. Skills, reusable playbooks
3. Soul, the agent's personality
4. Crons, scheduled jobs in fresh sessions
5. A self-improving loop, feedback into memory and skills

Moritz Kremb's Claude Code setup, shown in petergyang's diagram and outlined again in petergyang's episode post, uses four layers:

1. Folders for instructions, context, memory, and secrets
2. Tools, split across CLIs, MCPs, and APIs
3. Skills, with separate project and user skill libraries
4. Routines, split between local and remote jobs

The overlap is the story. Both systems treat chat as the thinnest layer on top of files, tools, and recurring jobs.

The setup advice that keeps repeating is mostly ops hygiene.

According to shannholmberg on agent folders, each Hermes agent gets its own project folder with IP, admin password, container details, and API keys so Claude Code can repair the agent when something breaks. According to shannholmberg on config set, secrets should be written from inside the container with hermes config set, which keeps them in .env instead of chat logs.

The permission model is equally explicit:

• One mailbox per agent, not your personal one, per shannholmberg on agent identities
• One set of API keys per agent for spend visibility, also per shannholmberg on agent identities
• A new agent when the work needs separate credentials, separate long-term memory, or a distinct role, per shannholmberg on when to add a second Hermes
• No mega-agent stuffed with every key, again per shannholmberg on when to add a second Hermes

The failure mode in the evidence is stale state, not lack of prompting. shannholmberg on stale memory calls stale memory.md and soul.md the top source of weird behavior, while shannholmberg on compaction says Hermes will compact around 136K tokens, insert a fallback marker, pause crons, update memory, and keep going.

The personal-OS framing gets concrete once you look past the slogan.

Peter Yang's episode post says Moritz Kremb runs email, content, and grocery shopping through Claude Code, with layers for folders, tools, skills, and routines petergyang's episode post. Aakash Gupta's feature card fills in the lower-level mechanics aakashgupta's 15-feature card:

• SOUL.md for permanent identity and push-back rules
• USER.md and MEMORY.md for long-lived context
• hermes backup --quick for state snapshots before experiments
• /insights for usage and decision analytics
• hermes gateway install to keep jobs running across reboots
• /steer to correct the agent mid-task without restarting
• /btw for side questions that do not pollute the thread
• /compress to shrink long sessions
• hermes --continue to resume a previous session
• hermes cron and hermes webhook subscribe for scheduled and event-driven work
• Skill files that auto-register as slash commands
• AGENTS.md for project-level context
• A checkpoint every 15 tool calls that patches or writes a skill file

That lines up with shannholmberg's Hermes terminal screenshot, which shows Hermes Agent v0.13.0 exposing 18 toolsets and 84 skills in one running environment. The screenshot also shows the agent pinned to claude-opus-4.7, which is a reminder that most of the novelty here is harness design, not a brand new model.

The most concrete creator workflow in the evidence is a short-video pipeline.

According to petergyang's short-video workflow clip, Moritz Kremb's system runs like this:

1. Cron jobs scrape ideas from X and YouTube
2. AI turns those into rough script notes
3. Kremb iterates on the notes with AI
4. He records the final script on his phone, with no AI voice
5. Postiz CLI auto-posts to YouTube, Instagram, and TikTok

That workflow pairs neatly with shannholmberg on hand-editing, which argues that the non-negotiable is still hand-editing every draft so the system accelerates original work instead of flattening it into slop. It is a useful correction to the fully automated fantasy, and it is one more sign that these personal-OS setups are settling into a specific role: persistent research and admin scaffolding around a human final pass.