--- title: How to Become a Hermes Agent Operator summary: >- Learn how to operate and master Hermes Agent: set up the agent control room template, configure specialist agents, and grow from one agent to a whole marketing company running on a single VPS you control from your phone. author: Shann³ authorUrl: 'https://x.com/shannholmberg' category: Architecture difficulty: Intermediate readingTime: 5 date: '2026-06-26' tags: - control-room - vps - fleet - orchestration - docker - marketing - operator integrations: - Hermes Agent - Docker - Hetzner - Telegram - Discord - Slack agents: - name: Agent Control Room role: >- A side control plane (a folder, not a chat agent) that documents and governs the whole fleet — which agents exist, what they do, what ports and credentials they reference, and how to restart, debug, or rebuild any of them. - name: Hermes Orchestrator role: >- An optional front door that reads the control room, routes work to the right specialist via the task bus, and synthesizes multi-agent results. - name: SEO Agent role: >- A specialist running the full pipeline from keyword seed to published article — 21 steps across research, production, and distribution, all inside one Docker container. - name: Company Brain role: >- The top-layer shared context — vision, brand, audience, products — that every other agent inherits. --- ## What Hermes Agent is Short version: an autonomous agent that gets more capable the longer it runs. Longer version: Hermes is a framework built by Nous Research that turns a model into a persistent operator. It has its own memory that survives between sessions. It writes its own skills as it works. It ships with 100+ skills already built in (GitHub workflows, Obsidian, Google Workspace, Linear, Notion, Typefully, Perplexity, deep research, and more). It lives wherever you put it — your laptop, a Docker container, a VPS, or a serverless runtime — and you can talk to it through 20+ surfaces: Telegram, Discord, Slack, email, voice mode, or just your terminal. Most AI tools answer questions. Hermes runs your workflows end-to-end. It navigates your browser, executes terminal commands, schedules cron jobs, monitors your inboxes, drafts the work, and posts the result wherever you live. > Nothing here is for sale. Hermes is open source, Nous Portal has a free tier, and most of the community ecosystem is free too. Fork it, change it, make it yours. ## How it works (the reader-friendly version) Every Hermes agent has three things. **A brain.** Memory lives at `~/.hermes/memories/`. Two files, `MEMORY.md` and `USER.md`, inject at session start — your voice rubric, brand notes, customer language, and last week's corrections all load before the first prompt. Sessions are stored in SQLite and recall across sessions is full-text searchable. **A personality.** `soul.md` is where the vibe lives: concise, sarcastic, blunt, formal, fast, or thoughtful. You can spin up several agents and give each a different soul over the same brain — one outbound rep with a closer's energy, one researcher who likes long sentences, one assistant who keeps everything short. **A skillset.** 100+ skills out of the box, plus a closed learning loop: as the agent works, it writes new skills along the way. Your own skills library grows on top of the bundled ones without you writing them. The closed learning loop is what separates this from a smart chatbot. The agent watches itself work, writes new skills as it learns the shape of your work, refines its memory periodically, and recalls past context across sessions. You don't have to re-teach it next week. > The rule I tell people new to Hermes: do not try to write your own skills on day one. Run real work, let the agent watch, and let the harness write the skills. You build a custom skill library faster by working than by writing prompts. ## What I'm running on Hermes I'm an AI marketer, not a coder. Most of what I run on Hermes is marketing infrastructure with the occasional internal tool: - A **personal assistant** that lives in Telegram, flags the four emails worth reading every morning, schedules reminders, and summarizes meetings I missed. - A **prototyping bench** where I test new flows (lead magnet, ad creative review, content sprint) against real work for a few runs before promoting them. - **Specialized agents** — SEO, outbound/BD, design review, content writing — each with its own soul and scope. - A **company brain** that monitors Slack, chats, emails, transcripts, and voice memos and makes all of it queryable. - An **SEO agent** that runs the full pipeline from keyword seed to published article in one Docker container, 21 steps, no human in the middle until the final review. - A **content distribution agent** that atomizes long-form into platform-specific posts for LinkedIn, X, and Threads. - An **orchestrator** that produces no work itself — it just routes requests to the right specialist. The SEO agent maps cleanest to the architecture in the rest of this guide — five layers, all inside one Docker container, 21 steps from keyword seed to published article: ```text [research + ideate] 01 keyword seed 05 content + visual gap 02 serp snapshot 06 internal validation 03 competitor extract 07 external validation 04 intent + format [production] 08 angle + brief 12 image gen 09 visual strategy 13 flowchart gen 10 outline 14 visual qa 11 draft 15 article qa [distribution] 16 publish prep 19 syndication 17 schema 20 analytics setup 18 internal linking 21 monitoring ``` Why one container instead of three: SEO work is sequential. Research feeds the brief, the brief feeds production, production feeds distribution. Every step needs memory of what was decided upstream. Clone the SEO template, swap the brain (SEO brain → outbound brain, or → design brain), and you have a new agent for any function with the same five-layer shape. ## The four-part mental model The setup has four parts: - **You** are the operator, with direct access to every part of the system. - **The agent control room** is the side control plane. It is *not* an agent you chat through — it is a folder (e.g. `/root/vps-agents`) that documents and governs the whole fleet. - **The Hermes agents** are the workers. Some are specialists (SEO, dev, CMO, ops). One can optionally be an orchestrator. - **The agent task bus** is an optional handoff desk between the orchestrator and the specialists. ```text ┌───────┐ │ YOU │ the operator └───┬───┘ │ ┌─────────────────────────────┼─────────────────────────────┐ │ │ │ control path orchestrated path direct path ▼ ▼ ▼ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ │ AGENT CONTROL ROOM │ │ HERMES ORCHESTRATOR│ │ SPECIALIST AGENT │ │ /root/vps-agents │ │ (optional door) │ │ seo · dev · cmo · │ │ docs · rules · │ └─────────┬──────────┘ │ ops · life │ │ runbooks · env-map │ │ delegates │ talk to it │ │ no raw secrets │ ▼ │ directly, │ │ side control plane │ ┌────────────────────┐ │ no routing │ └────────────────────┘ │ AGENT TASK BUS │ └────────────────────┘ │ /srv/agent-bus │ ──routes──▶ specialists └────────────────────┘ ``` The storage split matters more than people think: ```text /root/vps-agents → control room: docs, rules, runbooks, architecture no raw secrets, ever /srv//data → live runtime: secrets, memory, skills, sessions, crons this is where each hermes agent lives ``` The control room is the brain that defines the system. The live runtime is the body that runs it. You can rebuild the body from the brain — you cannot rebuild the brain from the body. Inside the control room: ```text /root/vps-agents/ README.md CLAUDE.md agents/ / inventory.md docker.md env-map.md runbook.md backup.md shared/ security.md commands.md api-keys-sop.md orchestrator-and-fleet-skills.md ``` And inside each agent's runtime at `/srv//data/`: ```text .env config.yaml SOUL.md memories/ skills/ cron/ sessions/ logs/ state.db ``` ## Three ways you interact ```text control path: you ──────► agent control room (add agents, rotate keys, update docs, debug setup) direct path: you ──────► hermes-seo (talk to a specialist directly, fastest) orchestrated path: you ──► hermes-orchestrator ──► task bus ──► specialists ──► you (one front door, routes and synthesizes multi-agent work) ``` ## From one agent to a full fleet **Level 1: one agent.** Fill in `SOUL.md` with the voice you want, `MEMORY.md` with the stable facts about your business, and `USER.md` with the stable facts about you. Connect it to Telegram or Discord so it lives where you do, then use it on real tasks and let it write its own skills along the way. **Level 2: direct specialist agents.** Multiple specialized agents, but you still talk to each directly — no orchestrator yet. The trap to avoid is reaching for an orchestrator before you've proven your specialists are useful. Decide when to spin up a new agent: ```text needs its own credentials → new agent needs its own long-term memory → new agent ongoing repeated work / role → new agent otherwise → stay with what you have ``` **Level 3: orchestrator + specialists.** You add `hermes-orchestrator` as a front door. It reads the control room to know which agents exist, what each does, where task queues live, what requires approval, and which actions are forbidden — it doesn't ask you, it reads it. This is the moment your setup stops being a collection of agents and starts being a team. **Level 4: automated agent team.** Same shape as level 3, but with recurring workflows and stronger automation. Weekly reports run on cron, server health checks fire daily, backup verification runs without you asking. This is what a marketing department in your terminal looks like — it shows up to work on its own and only pings you for the decisions that need taste. A quick check-in on the fleet from your laptop or phone: ```shell $ ssh hermes hermes-vps-1 ~ $ cd vps-agents hermes-vps-1 ~/vps-agents $ docker ps --format "table {{.Names}}\t{{.Status}}" NAMES STATUS hermes-orchestrator up 14 hours hermes-seo up 8 hours hermes-cmo up 8 hours hermes-outbound up 4 hours hermes-life up 12 hours ``` ## The setup guide: point your agent at the repo There's a public template that holds the exact structure above, plus the skills your agent needs to set it up for you. It lives at [github.com/shannhk/hermes-agent-control-room](https://github.com/shannhk/hermes-agent-control-room). You can clone it manually, but the point is you don't have to — if you have Claude Code or Codex on your laptop, the agents do most of the work after you hand over a Hetzner API key. ```text you ──► generate a Hetzner API key (sign up, generate a token, drop it in your .env) │ ▼ agent ──► create-vps skill spins up a Hetzner box, generates an SSH key, writes the alias to ~/.ssh/config so `ssh hermes` works │ ▼ agent ──► setup-control-room skill installs Node, Docker, Claude Code, Codex CLI, Hermes, then clones the repo to /root/agent-control-room │ ▼ you ──► finish interactive auth on the VPS (claude /login, codex, hermes) │ ▼ agent ──► agent-control-room skill registers your first hermes agent, fills the runbook, writes env-map │ ▼ you are at level 1 with a documented agent ``` Within 10–15 minutes you have a fresh VPS with the right tooling, the control room cloned, the bundled skills linked, one agent registered with its runbook and env-map filled in, and an `ssh hermes` alias on your laptop. ## The prototype → production methodology Most workflows don't start as production ones — they start messy. You discover them by running them. The four-step path: 1. **Prototype in Hermes.** Describe what you want and let it try. It'll get most of it wrong on the first run. That's fine. 2. **Run it 2–3 times against real work,** correcting drift each time. The harness watches every correction and writes the skill as it learns. By run three the agent does most of what you want without coaching. 3. **Fine-tune in a dedicated workspace.** Tighten prompts, lock routing, add error handling, decide what runs on cron. 4. **Deploy to a VPS on a schedule.** Once it survives a week of real runs without babysitting, push it to its own Docker container, set the cron, and walk away. You cannot write a production agent from scratch — you have to grow one. Hermes makes the growing part fast. ## Honest trade-offs 1. **The bundled defaults are also opinions.** If you want primitives with explicit control over every step, Hermes will feel heavy — pick the tool that matches your philosophy. 2. **Levels 3 and 4 have a real learning curve.** Docker, VPS, SSH, the control room structure — none of this is "install and go." Don't jump to level 3 if you aren't already running Hermes at level 1 daily. 3. **The model still matters.** Hermes makes a good model great; it doesn't make a small model a strategist. Use the strongest models you can afford for the work that matters, and cheaper models for the work that doesn't. ## Resources - **The official docs** — start with the install guide, then the skills page so you understand what ships out of the box. - **The control room template** — [github.com/shannhk/hermes-agent-control-room](https://github.com/shannhk/hermes-agent-control-room), the exact structure described above, ready to clone. - **The community atlas** — a curated map of 100+ open-source tools, plugins, workspaces, and integrations built on Hermes. - **[@NousResearch](https://x.com/NousResearch) on X** — official feature announcements. - **The meetups** — in-person Hermes meetups are happening now. You learn more in 90 minutes of side conversations than in a week of reading. None of this is magic. It's a framework that pays back because the memory persists, the skills accumulate, and the agents stay scoped. --- *This flow was shared by [Shann³](https://x.com/shannholmberg). Follow him for more on operating Hermes at scale. Hermes Agent is an open-source project by Nous Research.*