# How to Become a Hermes Agent Operator
**作者**: Shann³
**日期**: 2026-05-12T17:18:16.000Z
**来源**: [https://x.com/shannholmberg/status/2055335043904492011](https://x.com/shannholmberg/status/2055335043904492011)
---
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 on one VPS.
most AI tools answer questions. Hermes agent 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 to wherever you live: telegram, discord, slack, the email thread you're in right now.
built by @NousResearch and it's open source with 150,000 github stars. Currently ranks #1 on OpenRouter for global token usage.
its the framework I have built my entire marketing operation around for the past few weeks, and the article you are about to read is how I would set it up if I were starting today.
## what you'll get from this article
- what hermes agent is and why marketers (not just developers) should care
- the reader-friendly version of the architecture: the brain, the personality, the skillset, and how they all live in one folder
- the use cases I am personally running on hermes, with the four posts I have published about them
- the four-part mental model (you, control room, agents, optional task bus) and the four levels of setup, from "one agent on your laptop" to "a fully automated agent team on a VPS that you control from your phone"
- the prototype → production methodology I use to take a marketing workflow from messy idea to autonomous deployment
- the resources I would have wanted on day one: docs, the community atlas, the people to follow, the meetups happening right now
- the honest trade-offs and where this still breaks
I am not selling you anything in this article. hermes is open source, Nous Portal has a free tier, and most of the community ecosystem is free too. fork, change, make it yours.
## 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 123 skills already built in (github workflows, obsidian, google workspace, linear, notion, typefully, perplexity, deep research, plus 100+ more). it lives wherever you put it, on your laptop, in a docker container, on a VPS, in a serverless runtime. and you can talk to it through 20+ surfaces: telegram, discord, slack, email, voice mode, or just your terminal.
> **Shann³@shannholmberg**: [原文链接](https://x.com/shannholmberg/status/2054249815291351207)
>
> Hermes Agent changed how I work
> it's the highest leverage agent framework you can set up right now
> what makes it different:
> > it routes tasks to the right model based on complexity and cost
> > learns your voice and preferences over time
> > handles context switching without
>
> 
> 
if you have used claude code or openclaw, hermes is the same shape with a different philosophy.
> hermes is rails. opinionated defaults, batteries included, productive on day one with minimal setup, the agent does more thinking for you.
> openclaw is linux. primitives, guarantees, explicit control, the agent does exactly what you told it to and nothing more.
both are valid. I run hermes because the bundled defaults compound. every project I start with hermes is one where the agent already knows how to do 100+ things before I write a line of configuration. that head start is worth it for me. I´ve also noticed that hermes doesn´t have where near the same issue with gateway disconnecting or bugging.
proof is in the numbers Nous Research just hit:
- #1 on OpenRouter for global token usage (out of every model and framework on the platform)
- 150,000 github stars on the hermes repo
- 123 bundled skills before the agent writes one of its own
- 70+ built-in tools in the gateway, plus 300+ models through one subscription
- 6 deployment targets: local, docker, ssh, daytona, singularity, modal
- 20+ messaging surfaces: telegram, discord, slack, email, voice
if you are an AI marketer and you have not started running hermes yet, you are leaving compounding capability on the table every week.
## 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, your brand notes, your customer language, last week's corrections, all of it loads before the first prompt. sessions are stored in sqlite, 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 six agents and give each one a different soul, same brain underneath. one is your outbound rep with a closer's energy. another is your researcher who likes long sentences. another is your assistant who keeps everything short.
## a skillset.
123 skills out of the box: github PRs, obsidian, google workspace, linear, notion, typefully, perplexity, deep research, browser control, web scraping, vision, voice, scheduling. and the closed learning loop: as the agent works, it writes new skills along the way. your own skills library grows on top of the 123 without you having to write any of them.
then there is what the agent can talk to.
- the tool gateway: one subscription, 300+ models, plus web scraping and browser automation built in
- MCP integration: any external service that speaks Model Context Protocol becomes a tool your agent can use
- 20+ messaging surfaces: telegram, discord, slack, email, voice, plus the CLI itself
and where the agent can live.
- your laptop (local)
- a docker container (isolated, portable, the way I run mine)
- an ssh session on a VPS (so it runs even when your laptop is closed)
- daytona, singularity, modal (serverless if you don't want to manage infrastructure)
the closed learning loop is what makes this different 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 using a mix of full-text search and LLM summarization. you do not have to re-teach it next week.
> the rule I tell people new to hermes is this:
> 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 am an AI marketer, not a coder. most of what I run on hermes is marketing infrastructure with the occasional internal tool. here is the actual list:
- a personal assistant that handles business and private, lives in telegram, flags the four emails worth reading every morning, schedules my reminders, summarizes meetings I missed
- a marketing workflow prototyping bench where I test new flows (lead magnet, ad creative review, content sprint) against real work for 2-3 runs before promoting them
- specialized marketing agents: SEO, outbound / BD, design review, content writing, each one with its own soul and its own scope
- a company brain that monitors slack, chats, emails, transcripts, voice memos, and makes all of it queryable. when I ask "what did we say to that client about pricing last month" I get the answer in 3 seconds instead of 30 minutes of digging
- 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 takes a piece of long form (this article, for example) and atomizes it across LinkedIn, X, Threads, with platform-specific hooks
- an orchestrator agent that does not produce work itself, just routes requests to the right specialist based on what I'm asking for
the blueprint I posted that summarized it:
> **Shann³@shannholmberg**: [原文链接](https://x.com/shannholmberg/status/2054542245475578147)
>
> the org chart for my Hermes Agent company
> four layers, all isolated docker containers on one vps:
> 1. company brain - vision, brand, customers, products. the context every other layer inherits
> 2. orchestrator hermes agent - reads the company brain, picks the right department,
>
> 
> 
the SEO agent in particular is worth zooming in on, because it is the one I have shipped publicly and the one that maps cleanest to the architecture in the rest of this article. five layers, all inside one docker container, 21 steps from keyword seed to published article.
the 21 steps look like this in the terminal:
```
[research + ideate]
01 keyword seed
02 serp snapshot
03 competitor extraction
04 intent + format analysis
05 content + visual gap
06 internal validation
07 external validation
[production]
08 angle + positioning brief
09 visual strategy brief
10 outline
11 draft
12 image gen
13 flowchart gen
14 visual qa
15 article qa
[distribution]
16 publish prep
17 schema
18 internal linking
19 syndication
20 analytics setup
21 monitoring
```
the layers above this pipeline:
1. company brain at the top: vision, brand, audience, products. every agent reads from this
2. orchestrator hermes agent: takes the topic or keyword seed and routes it to the seo agent
3. seo brain: ranking playbook, voice rules, content formats, visual style guide, success criteria per format. all seo-specific context lives here
4. three sub-agents inside the SEO agent, each one handling a phase:
5. research + ideate: keyword seed, serp snapshot, competitor extraction, intent and format analysis, content and visual gap, internal and external validation
6. production: angle and positioning brief, visual strategy brief, outline, draft, image gen, flowchart gen, visual and article qa
7. distribution: publish prep, schema, internal linking, syndication, analytics, monitoring
8. one docker container holds all three sub-agents. they share env, memory, and tools. sub-profiles switch context per phase. one process, one filesystem, one set of credentials.
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. splitting into three containers means shuttling state across boundaries, which gets expensive and breaks the chain.
every other specialized agent in the company runs on the same template. clone the SEO agent template, swap the brain (seo brain → outbound brain, or → design brain, or → support brain), and you have a new agent for any function with the same five-layer shape.
> **Shann³@shannholmberg**: [原文链接](https://x.com/shannholmberg/status/2054958228149342621)
>
> how my hermes seo agent works in the org chart
> it runs the full pipeline from keyword seed to published article, 21 steps, all inside one docker container
> the structure:
> LAYER 1: company brain
> shared context: vision, brand, audience, products. every agent reads from this
>
> 
> 
> the layers are not decoration. they are the reason the agent does not lose context as the work gets specialized. the company brain stays stable while the worker iterates. the brain layers make the worker disposable.
I also hosted Nous Research at our @EspressioAI HQ in Lisbon for a Hermes Agent evening recently. @yeahfortommy from Nous ran a Q&A, Simao from noticed .so showed an agent harness with autoresearch, and I walked through how we are using hermes for growth at Espressio.
> **Shann³@shannholmberg**: [原文链接](https://x.com/shannholmberg/status/2048747512006324527)
>
> we are hosting @NousResearch for a Hermes Agent evening at the Espressio HQ tomorrow
> @touchgrassklub is organizing in collabration with Talent Protocol
> Here´s the agenda for the evening:
> > I´ll start by talking about using Hermes Agent for growth, what we're shipping at
>
> 
> 
if you are in Lisbon and want to come to the next one, I will post when it's scheduled.
## from one agent to a full fleet
before the levels, the mental model.
the setup has four parts:
- you are the operator. you have 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 at /root/vps-agents that documents and governs the whole fleet. you open it, edit it, inspect it, or ask claude, codex, or hermes to use it when you are managing the system.
- the hermes agents are the workers. some are specialists (seo, dev, cmo, ops). one of them can optionally be an orchestrator.
- the agent task bus is an optional handoff desk that sits between the orchestrator and the specialists. you only need it once you have an orchestrator in play.
the whole thing looks like this:
```
┌───────┐
│ YOU │ the operator
└───┬───┘
│
┌─────────────────────────────┼─────────────────────────────┐
│ │ │
control path orchestrated path direct path
│ │ │
▼ ▼ ▼
┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐
│ AGENT CONTROL ROOM │ │ HERMES │ │ SPECIALIST AGENT │
│ /root/vps-agents │ │ ORCHESTRATOR │ │ │
│ │ │ (optional door) │ │ seo · dev · cmo · │
│ docs · rules · │ └─────────┬──────────┘ │ ops · life │
│ runbooks · env-map │ │ delegates │ │
│ · registry │ ▼ │ talk to it │
│ │ ┌────────────────────┐ │ directly, │
│ side control plane │ │ AGENT TASK BUS │ │ no routing │
│ no raw secrets │ │ /srv/agent-bus │ │ │
│ │ └─────────┬──────────┘ │ │
└────────────────────┘ │ │ │
│ routes │ │
└───────────────▶ │
│ │
└────────────────────┘
the agent control room governs every agent in this diagram. it is the
single source of truth, and the place you go to manage the fleet, not
the place you go to run work through it.
```
the storage split matters more than people think:
```
/root/vps-agents → control room: docs, rules, runbooks, architecture
no raw secrets, ever
/srv/<agent-name>/data → live runtime: secrets, memory, skills, sessions, crons
this is where each hermes agent lives
```
the control room contains the answers to questions like which agents exist, what they do, what ports they use, what credentials they reference, what each agent can and cannot do, and how to restart, debug, or rebuild any of them. the live runtime contains the actual workings.
> 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:
```
/root/vps-agents/
README.md
CLAUDE.md
agents/
<agent-name>/
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/<agent-name>/data/:
```
.env
config.yaml
SOUL.md
memories/
skills/
cron/
sessions/
logs/
state.db
```
## three ways you interact
```
control path:
you ──────► agent control room
(add agents, rotate keys, update docs, debug setup)
direct path:
you ──────► hermes-seo-espressio
(talk to a specialist directly, fastest)
orchestrated path:
you ──► hermes-orchestrator ──► task bus ──► specialists ──► you
(one front door, routes and synthesizes multi-agent work)
```
- control path is the meta layer. used when adding agents, reviewing docs, checking ports, rotating keys, debugging setup.
- direct path is the fastest. used when you already know which agent does the work.
- orchestrated path is the synthesizer. used when you want one front door that routes and combines work across multiple specialists.
## level 1: one agent
you have one hermes agent. that is it. the control room can still exist (recommended) but it only documents that one agent.
```
you → one hermes agent
control room → documents that one agent
```
best for: initial setup, your personal hermes, root install documentation, simple docker migration.
one agent, lived-in, with a personality you have tuned and a memory that has started to build. 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. start using it on real tasks. let it touch your tools. let it write its own skills along the way.
MEMORY.md holds the stable facts (what your business is, who your customers are, what your products do). USER.md holds the stable facts about you (timezone, working hours, recurring projects, preferred output formats). both get refined every week as you correct the agent in real conversations.
## level 2: direct specialist agents
you have multiple specialized agents, but you still talk to each one directly. no orchestrator yet.
```
you → hermes-life
you → hermes-seo-espressio
you → hermes-dev
you → hermes-cmo
```
the control room documents all of them.
best for: clear role separation, testing which agents are useful, avoiding premature orchestration, keeping credentials scoped per agent.
> the trap to avoid here is reaching for an orchestrator before you have proven your specialists are useful. spin up two or three, run them directly, and only add an orchestrator when you find yourself wanting one front door.
when to spin up a new agent vs stay with what you have:
```
needs its own credentials → new agent
needs its own long-term memory → new agent
ongoing repeated work that is a separate role → new agent
otherwise stay with what you have
```
bad pattern: one mega-agent with every credential and every memory layer mashed together. you lose isolation, you lose the ability to revoke access cleanly, and the agent gets confused about which voice to use.
## level 3: orchestrator + specialists
you add hermes-orchestrator as a front door. you can still talk directly to specialists, but the orchestrator can route work and synthesize results.
the orchestrator reads the control room to know which agents exist, what each one does, where task queues live, what requires approval, which actions are forbidden, and where docs and runbooks are. it does not need to ask you any of that, it reads it.
best for: cross-functional work, delegation, summary and synthesis, one main interface for multi-agent workflows.
> the orchestrator is the moment your setup stops being a collection of agents and starts being a team. it is also the moment where the control room earns its keep, because the orchestrator is only as good as the docs it reads.
what a quick check-in on the fleet looks like from my laptop or phone:
```
$ ssh hermes
welcome to hermes-vps-1.
last login: thu may 15 09:14:22
hermes-vps-1 ~ $ cd vps-agents
hermes-vps-1 ~/vps-agents $ docker ps --format \
"table {{.Names}}\t{{.Status}}\t{{.Image}}"
NAMES STATUS IMAGE
hermes-orchestrator up 14 hours hermes-runtime
hermes-seo-espressio up 8 hours hermes-runtime
hermes-cmo up 8 hours hermes-runtime
hermes-outbound up 4 hours hermes-runtime
hermes-life up 12 hours hermes-runtime
hermes-vps-1 ~/vps-agents $ cat agents/hermes-seo-espressio/runbook.md
# runbook: hermes-seo-espressio
restart: docker compose restart hermes-seo-espressio
logs: docker logs -f hermes-seo-espressio
shell: docker exec -it hermes-seo-espressio bash
...
```
> **Shann³@shannholmberg**: [原文链接](https://x.com/shannholmberg/status/2054309307492290988)
>
> my entire Hermes Agent setup is controlled from one folder on a VPS
> I can manage it from my laptop or phone in under 10 seconds, spin up isolated agents per project, and never lose context
> here's the full setup:
> > bash command "ssh hermes" auto-connects to the VPS
> > session
>
> 
> 
## level 4: automated agent team
ame shape as level 3, but with recurring workflows and stronger automation. weekly seo reports run on cron. server health checks fire daily. backup verification runs without you asking. cross-agent business workflows kick off on schedule.
best for: weekly seo reports, content operations, server health checks, backup verification, cross-agent business workflows.
> level 4 is what a marketing department in your terminal looks like. it does not need you to start the day. it shows up to work on its own, files reports, checks itself, and only pings you for the decisions that need taste.
## the control hierarchy
one principle to keep in your head as you climb the levels.
the control room is for config, docs, runbooks, and governance. it documents which agents exist, what they do, where they run, which credentials they reference, what each agent can and cannot do. it is the admin panel for the fleet, including the orchestrator. it is not where you go to do work.
for work, you talk to the agents directly. either a specialist (when you know which agent owns the job) or the orchestrator (when you want one front door to route across specialists).
## the setup guide: point your agent at the repo
now you understand the architecture. here is how you build it.
I shipped a public template that holds the exact structure described above, plus the skills your agent needs to set it up for you.
it lives at github.com/shannhk/hermes-agent-control-room.
you can clone it manually, but the point is that you do not 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.
the automated flow:
```
you ──► generate a Hetzner API key
(5 min: 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 Agent, then clones the repo to the VPS
at /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 in the docs,
fills in the runbook, sets up the env-map
│
▼
you are at level 1 with a documented agent
```
within ten to fifteen minutes you have:
- a fresh Hetzner VPS with the right tooling installed
- the control room cloned at /root/agent-control-room on the VPS
- the bundled skills linked into ~/.claude/skills on the VPS
- one hermes agent registered, runbook filled in, env-map written
- an SSH alias on your laptop so ssh hermes connects instantly
## the prototype → production methodology
most workflows do not start as production ones. they start messy. a flow that runs SEO research, drafts an article, schedules it in Typefully, and posts it to LinkedIn does not exist in your head fully formed. you discover it by running it.
hermes is the prototyping environment for this. here is the four-step path I use to take any new marketing workflow from idea to autonomous deployment:
1. prototype in hermes. open your main hermes agent, describe what you want to happen, and let it try. it will 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 starts writing the skill as it learns the shape. by run three the agent is doing most of what you want without coaching.
3. fine-tune in a dedicated workspace. pull the workflow into a separate Claude Code workspace (or a fresh hermes agent if you prefer), tighten the prompts, lock the routing, add error handling, decide what should run on cron and what should be triggered.
4. deploy to a VPS on a schedule. once it survives a week of real runs without you babysitting it, push it to its own docker container on your VPS, set the cron, walk away.
I learned this pattern after burning a few weekends trying to write production-ready agents from scratch. you cannot write a production agent from scratch. you have to grow one. hermes makes the growing part fast.
1. prototype in hermes
2. fine-tune in a dedicated workspace
3. deploy autonomous on a VPS
## the models I run on hermes
hermes gives you the framework. the model underneath is your choice. through the tool gateway you can route to 300+ models from one subscription, switching per agent or per task.
what I personally run today:
- claude opus 4.7 for the creative work: copywriting, voice, hook generation, content drafting, anything where taste and writing quality matter
- codex (gpt 5.5) for the structured work: coding, planning, multi-step workflows, browser automation, scraping, anything where the steps need to be tight and the output predictable
I run both. opus writes. codex builds and plans. hermes makes routing easy, you point each agent at the model that fits the work it does.
if you can only run one, the answer depends on what kind of work your fleet is doing. heavy on content and copy? start with claude opus 4.7. heavy on infrastructure, automation, and engineering workflows? start with codex. you can always add the second model later through the same tool gateway.
## honest trade-offs
I am not going to pretend hermes is perfect. three real trade-offs.
1. the bundled defaults are also opinions.hermes ships with strong defaults for how memory works, how skills get written, how the agent uses tools. that is the whole pitch. but it also means if you want primitives with explicit control over every step, hermes will feel heavy. openclaw is the better fit for that taste. pick the tool that matches your philosophy.
2. level 3 and 4 have a real learning curve.docker, VPS, SSH, the control room folder structure, the orchestrator skills, none of this is "install and go." you should not jump to level 3 if you are not already running hermes at level 1 daily.
3. the model still matters.hermes is a framework that makes a good model great. it does not make a small model into a strategist. use the strongest models you can afford for the work that matters (your orchestrator, your strategy agent, your brain). drop to cheaper models for the work that does not (research scraping, draft generation, batch processing).
> none of this is magic. it is a framework that pays back because the memory persists, the skills accumulate, and the agents stay scoped. apply it to the wrong-sized model and you get a confused team. apply it to the right one and you get a team.
## resources
if you are starting today, here is what I would read in order.
- the official docs: hermes-agent.nousresearch.com/docs. start with the install guide, then read the skills page so you understand what ships out of the box
- the control room template (my repo): github.com/shannhk/hermes-agent-control-room. the exact structure I described above, ready to clone. control-room-first template for managing hermes agents from one VPS agent to specialist teams and orchestrated workflows. fork it and make it yours
- hermesatlas.com: the community-curated map of 100+ open source tools, plugins, workspaces, and integrations built on hermes. categorized by domain (memory providers, workspaces, skill registries, deployment, orchestration). also includes the Hermes Handbook, a beginner-friendly walkthrough. weekly updates, free newsletter
- @Teknium on X: Nous Research founder. ships hermes updates almost daily. the codex runtime integration, the DeepSeek V4 Flash free tier on Nous Portal, the pretext skills, all came through his feed first
- @NousResearch on X: the official account, official feature announcements
- the meetups: there are hermes meetups happening in person now (Lisbon, Ventura, more cities). worth showing up if there's one near you. you learn more in 90 minutes of side conversations than in a week of reading
Hope you got some value out of this, appreciate you reading the whole thing.
-- Shann
## 相关链接
- [Teknium reposted](https://x.com/Teknium)
- [Shann³](https://x.com/shannholmberg)
- [@shannholmberg](https://x.com/shannholmberg)
- [1.3M](https://x.com/shannholmberg/status/2055335043904492011/analytics)
- [@NousResearch](https://x.com/@NousResearch)
- [May 13](https://x.com/shannholmberg/status/2054249815291351207)
- [257K](https://x.com/shannholmberg/status/2054249815291351207/analytics)
- [May 13](https://x.com/shannholmberg/status/2054542245475578147)
- [141K](https://x.com/shannholmberg/status/2054542245475578147/analytics)
- [May 15](https://x.com/shannholmberg/status/2054958228149342621)
- [15K](https://x.com/shannholmberg/status/2054958228149342621/analytics)
- [@EspressioAI](https://x.com/@EspressioAI)
- [@yeahfortommy](https://x.com/@yeahfortommy)
- [Apr 27](https://x.com/shannholmberg/status/2048747512006324527)
- [@NousResearch](https://x.com/NousResearch)
- [@touchgrassklub](https://x.com/touchgrassklub)
- [24K](https://x.com/shannholmberg/status/2048747512006324527/analytics)
- [May 13](https://x.com/shannholmberg/status/2054309307492290988)
- [100K](https://x.com/shannholmberg/status/2054309307492290988/analytics)
- [github.com/shannhk/hermes-agent-control-room](https://github.com/shannhk/hermes-agent-control-room)
- [opinions.hermes](https://opinions.hermes/)
- [matters.hermes](https://matters.hermes/)
- [hermes-agent.nousresearch.com/docs](https://hermes-agent.nousresearch.com/docs)
- [github.com/shannhk/hermes-agent-control-room](https://github.com/shannhk/hermes-agent-control-room)
- [hermesatlas.com](https://hermesatlas.com/)
- [@Teknium](https://x.com/@Teknium)
- [@NousResearch](https://x.com/@NousResearch)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [1:10 AM · May 16, 2026](https://x.com/shannholmberg/status/2055335043904492011)
- [1.3M Views](https://x.com/shannholmberg/status/2055335043904492011/analytics)
- [View quotes](https://x.com/shannholmberg/status/2055335043904492011/quotes)
---
*导出时间: 2026/5/30 13:06:23*
---
## 中文翻译
# 如何成为 Hermes Agent 操作员
**作者**: Shann³
**日期**: 2026-05-12T17:18:16.000Z
**来源**: [https://x.com/shannholmberg/status/2055335043904492011](https://x.com/shannholmberg/status/2055335043904492011)
---
学习如何操作并精通 Hermes Agent。设置代理控制室模板，配置专业代理，并实现在一台 VPS 上从单个代理扩展为整个营销公司。
大多数 AI 工具只是回答问题。Hermes agent 则端到端地运行你的工作流。
它操控你的浏览器，执行终端命令，调度 cron 任务，监控你的收件箱，起草工作内容，并将结果发布到你所在的任何地方：Telegram、Discord、Slack，或者你当前所在的邮件线程中。
由 @NousResearch 构建，开源且拥有 15 万 GitHub stars。目前在 OpenRouter 的全球 token 使用量中排名第一。
过去几周，我一直围绕这个框架构建我所有的营销运营，而你即将阅读的这篇文章，讲述的是如果今天我要从头开始，我会如何设置它。
## 你将从本文获得什么
- Hermes agent 是什么，以及为什么营销人员（不仅仅是开发者）应该关注它
- 架构的通俗版本：大脑、个性、技能集，以及它们如何共存于一个文件夹中
- 我个人在 Hermes 上运行的实际用例，以及我发布的四篇相关文章
- 四部分思维模型（你、控制室、代理、可选的任务总线）和四个设置级别，从“你笔记本电脑上的一个代理”到“你可以用手机控制的 VPS 上的一支全自动代理团队”
- 我将营销工作流从混乱的想法转化为自主部署所使用的“原型 → 生产”方法论
- 我希望第一天就能拥有的资源：文档、社区图谱、值得关注的人、正在发生的聚会
- 真诚的权衡取舍以及目前仍然存在的缺陷
在这篇文章中，我不向你推销任何东西。hermes 是开源的，Nous Portal 有免费层级，而且大部分社区生态系统也是免费的。去 fork，去修改，让它成为你自己的工具。
## Hermes Agent 是什么
简短版：一个运行时间越长能力越强的自主代理。
长版本：hermes 是由 Nous Research 构建的框架，它将模型转化为持久化的操作员。它拥有自己的记忆，该记忆在会话之间得以保留。它会在工作时编写自己的技能。它内置了 123 项技能（github workflows、obsidian、google workspace、linear、notion、typefully、perplexity、deep research，外加 100 多项）。它栖身于你放置的任何地方：你的笔记本电脑、docker 容器、VPS 或无服务器运行时中。你可以通过 20 多种界面与它交谈：telegram、discord、slack、email、语音模式，或者仅仅是你的终端。
> **Shann³@shannholmberg**: [原文链接](https://x.com/shannholmberg/status/2054249815291351207)
>
> Hermes Agent 改变了我的工作方式
> 它是你目前能设置的最高效的代理框架
> 它的独特之处在于：
> > 它根据复杂度和成本将任务路由到正确的模型
> > 随着时间推移学习你的语气和偏好
> > 毫无障碍地处理上下文切换
>
> 
> 
如果你使用过 claude code 或 openclaw，hermes 形式相似但理念不同。
> hermes 就像 rails（Ruby on Rails）。有主见的默认配置，开箱即用，只需最少的设置即可在第一天高效产出，代理会为你做更多的思考工作。
> openclaw 就像 linux。原语、保证、显式控制，代理完全按照你告诉它的去做，不多不少。
两者都是合理的。我选择运行 hermes 是因为其打包的默认配置能产生复利效应。我使用 hermes 启动的每个项目，代理在还没写一行配置前就已经知道如何做 100 多件事。这种先发优势对我来说非常值得。我也注意到 hermes 几乎没有出现网关断连或 Bug 的问题。
证据就在 Nous Research 刚刚达成的数据中：
- OpenRouter 全球 token 使用量排名第一（在该平台的所有模型和框架中）
- hermes 仓库拥有 150,000 个 github stars
- 在代理自己编写技能之前已有 123 项捆绑技能
- 网关中有 70 多种内置工具，外加通过一个订阅即可使用 300 多个模型
- 6 种部署目标：本地、docker、ssh、daytona、singularity、modal
- 20 多种消息界面：telegram、discord、slack、email、voice
如果你是一名 AI 营销人员，却还没开始运行 hermes，那你每周都在错失能力的复利增长。
## 它是如何工作的（通俗版）
每个 hermes 代理都有三样东西。
一个大脑。记忆存储在 ~/.hermes/memories/。两个文件，MEMORY.md 和 USER.md，在会话开始时注入。你的语气准则、品牌笔记、客户语言、上周的更正，所有这些都会在第一个提示之前加载。会话存储在 sqlite 中，跨会话的回忆是全文可搜索的。
一个个性。soul.md 是气质所在。简洁。讽刺。直率。正式。快速或深思熟虑。你可以启动六个代理，给每个代理不同的灵魂，底层共用同一个大脑。一个是你的外展代表，具有成交者的能量。另一个是你的研究员，喜欢长句子。还有一个是你的助手，凡事求短。
## 技能集。
123 项开箱即用的技能：github PRs、obsidian、google workspace、linear、notion、typefully、perplexity、deep research、浏览器控制、网页抓取、视觉、语音、调度。以及闭环学习：随着代理的工作，它会沿途编写新技能。你自己的技能库是在这 123 项基础上增长的，而无需你编写任何代码。
然后是代理可以与什么对话。
- 工具网关：一个订阅，300 多个模型，外加内置的网页抓取和浏览器自动化
- MCP 集成：任何使用 Model Context Protocol（模型上下文协议）的外部服务都会成为你的代理可以使用的工具
- 20 多种消息界面：telegram、discord、slack、email、voice，外加 CLI 本身
以及代理可以栖身何处。
- 你的笔记本电脑（本地）
- docker 容器（隔离、可移植，这就是我的运行方式）
- VPS 上的 ssh 会话（这样即使你合上笔记本电脑它也在运行）
- daytona、singularity、modal（如果你不想管理基础设施，这是无服务器方案）
闭环学习是使其区别于智能聊天机器人的关键。代理观察自己的工作，在学习工作形态时编写新技能，定期优化记忆，并使用全文搜索和 LLM 摘要的结合来回忆过去的上下文。你下周不需要重教它。
> 我告诉 hermes 新手的规则是这样的：
> 不要在第一天尝试编写自己的技能。运行真实的工作，让代理观察，让系统为你编写技能。通过工作而不是编写提示词，你能更快地构建自定义技能库。
## 我在 Hermes 上运行什么
我是 AI 营销人员，不是程序员。我在 hermes 上运行的大部分是营销基础设施，偶尔有一些内部工具。这是实际清单：
- 一个处理公事和私事的个人助理，居住在 telegram 中，每天早上标记出四封值得读的邮件，安排提醒，总结我错过的会议
- 一个营销工作流原型台，我在这里用真实工作测试新流程（lead magnet、广告创意审查、内容冲刺），在实际推广前运行 2-3 轮
- 专业营销代理：SEO、外展/BD、设计审查、内容写作，每个都有自己的灵魂和范围
- 一个监控 slack、聊天、邮件、录音、语音备忘录的“公司大脑”，并使所有这些内容可查询。当我问“上个月我们就价格向那个客户说了什么”时，我在 3 秒内得到答案，而不是挖掘 30 分钟
- 一个 SEO 代理，在一个 docker 容器中运行从关键词种子到发表文章的完整流水线，21 个步骤，在最终审查前没有人工干预
- 一个内容分发代理，获取长篇内容（例如这篇文章）并将其通过特定平台的钩子分发到 LinkedIn、X、Threads
- 一个编排器代理，它本身不产生工作，只是根据我的要求将请求路由给正确的专家
我发布的总结它的蓝图：
> **Shann³@shannholmberg**: [原文链接](https://x.com/shannholmberg/status/2054542245475578147)
>
> 我的 Hermes Agent 公司的组织架构图
> 四层，全部位于一台 vps 上的独立 docker 容器中：
> 1. 公司大脑 - 愿景、品牌、客户、产品。其他层继承的上下文
> 2. 编排器 hermes agent - 读取公司大脑，选择正确的部门
>
> 
> 
SEO 代理特别值得放大来看，因为它是我公开发布过的代理，也是与本文其余部分的架构映射最清晰的代理。五层，全部位于一个 docker 容器内，从关键词种子到发表文章共 21 个步骤。
这 21 个步骤在终端中看起来像这样：
```
[research + ideate]
01 keyword seed
02 serp snapshot
03 competitor extraction
04 intent + format analysis
05 content + visual gap
06 internal validation
07 external validation
[production]
08 angle + positioning brief
09 visual strategy brief
10 outline
11 draft
12 image gen
13 flowchart gen
14 visual qa
15 article qa
[distribution]
16 publish prep
17 schema
18 internal linking
19 syndication
20 analytics setup
21 monitoring
```
该流水线之上的层级：
1. 顶层的公司大脑：愿景、品牌、受众、产品。每个代理都从这里读取
2. 编排器 hermes agent：接收主题或关键词种子并将其路由到 seo agent
3. seo brain：排名手册、语气规则、内容格式、视觉风格指南、每种格式的成功标准。所有 seo 特定的上下文都在这里
4. SEO agent 内部的三个子代理，每个处理一个阶段：
5. research + ideate（研究 + 构思）：关键词种子、serp 快照、竞品提取、意图和格式分析、内容和视觉差距、内部和外部验证
6. production（生产）：角度和定位简报、视觉策略简报、大纲、草稿、图片生成、流程图生成、视觉和文章 QA
7. distribution（分发）：发布准备、schema、内部链接、联合发布、分析、监控
8. 一个 docker 容器容纳所有三个子代理。它们共享 env、内存和工具。子配置文件在每个阶段切换上下文。一个进程，一个文件系统，一组凭据。
为什么用一个容器而不是三个：seo 工作是顺序的。研究喂给简报，简报喂给生产，生产喂给分发。每一步都需要对上游决策的记忆。拆分成三个容器意味着跨越边界来回传递状态，这既昂贵又容易破坏链条。
公司里的每个其他专业代理都运行在相同的模板上。克隆 SEO agent 模板，交换大脑（seo brain → outbound brain，或 → design brain，或 → support brain），你就拥有了任何功能的新代理，具有相同的五层结构。
> **Shann³@shannholmberg**: [原文链接](https://x.com/shannholmberg/status/2054958228149342621)
>
> 我的 hermes seo agent 在组织架构图中如何工作
> 它运行从关键词种子到发表文章的完整流水线，21 个步骤，全部在一个 docker 容器内
> 结构：
> LAYER 1: company brain（公司大脑）
> shared context: vision, brand, audience, products. every agent reads from this
>
> 
> 
> 这些层级不是装饰。它们是代理在工作变得专业化时不丢失上下文的原因。当工人在迭代时，公司大脑保持稳定。大脑层使得工人变得可替换。
最近，我还在里斯本的 @EspressioAI 总部为 Nous Research 举办了一个 Hermes Agent 之夜。来自 Nous 的 @yeahfortommy 举办了问答环节，noticed .so 的 Simao 展示了一个具有自动研究功能的代理系统，我介绍了我们在 Espressio 如何使用 hermes 实现增长。
> **Shann³@shannholmberg**: [原文链接](https://x.com/shannholmberg/status/2048747512006324527)
>
> 明天我们将在 Espressio HQ 举办 @NousResearch 的 Hermes Agent 之夜
> @touchgrassklub 正在与 Talent Protocol 合作组织此次活动
> 晚上的议程如下：
> > 我将首先谈谈使用 Hermes Agent 实现增长，我们正在发布什么
>
> 
> 
如果你在里斯本想来参加下一次活动，我会在安排好后发布消息。
## 从一个代理到整支舰队
在介绍级别之前，先讲思维模型。
设置包含四个部分：
- 你是操作员。你可以直接访问系统的每个部分。
- agent control room（代理控制室）是侧边控制平面。它不是一个用来聊天的代理。它是位于 /root/vps-agents 的一个文件夹，用于记录和管理整支舰队。你可以打开它、编辑它、检查它，或者在管理系统时要求 claude、codex 或 hermes 使用它。
- hermes agents 是工人。有些是专家（seo、dev、cmo、ops）。其中一个可以是可选的编排器。
- agent task bus（代理任务总线）是一个可选的交接台，位于编排器和专家之间。只有当你启用编排器时才需要它。
整个系统看起来像这样：
```
┌───────┐
│ YOU │ the operator
└───┬───┘
│
┌─────────────────────────────┼─────────────────────────────┐
│ │ │
control path orchestrated path direct path
│ │ │
▼ ▼ ▼
┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐
│ AGENT CONTROL ROOM │ │ HERMES │ │ SPECIALIST AGENT │
│ /root/vps-agents │ │ ORCHESTRATOR │ │ │
│ │ │ (optional door) │ │ seo · dev · cmo · │
│ docs · rules · │ └─────────┬──────────┘ │ ops · life │
│ runbooks · env-map │ │ delegates │ │
│ · registry │ ▼ │ talk to it │
│ │ ┌────────────────────┐ │ directly, │
│ side control plane │ │ AGENT TASK BUS │ │ no routing │
│ no raw secrets │ │ /srv/agent-bus │ │ │
│ │ └─────────┬──────────┘ │ │
└────────────────────┘ │ │ │
│ routes │ │
└───────────────▶ │
│ │
└────────────────────┘
the agent control room governs every agent in this diagram. it is the
single source of truth, and the place you go to manage the fleet, not
the place you go to run work through it.
```
存储的划分比人们认为的更重要