# 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
## 相关链接
- [Shann³](https://x.com/shannholmberg)
- [@shannholmberg](https://x.com/shannholmberg)
- [51K](https://x.com/shannholmberg/status/2055335043904492011/analytics)
- [@NousResearch](https://x.com/@NousResearch)
- [May 13](https://x.com/shannholmberg/status/2054249815291351207)
- [241K](https://x.com/shannholmberg/status/2054249815291351207/analytics)
- [May 13](https://x.com/shannholmberg/status/2054542245475578147)
- [132K](https://x.com/shannholmberg/status/2054542245475578147/analytics)
- [May 15](https://x.com/shannholmberg/status/2054958228149342621)
- [14K](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)
- [23K](https://x.com/shannholmberg/status/2048747512006324527/analytics)
- [May 13](https://x.com/shannholmberg/status/2054309307492290988)
- [97K](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)
- [51.6K Views](https://x.com/shannholmberg/status/2055335043904492011/analytics)
- [View quotes](https://x.com/shannholmberg/status/2055335043904492011/quotes)
---
*导出时间: 2026/5/16 18:42:21*
---
## 中文翻译
# 如何成为一名 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 代理可以端到端地运行你的工作流。
它可以操控你的浏览器，执行终端命令，调度 cron 作业，监控你的收件箱，起草工作内容，并将结果发布到你所在的任何地方：Telegram、Discord、Slack，或者你当前的邮件线程。
由 @NousResearch 构建，它是开源的，拥有 15 万 GitHub 星标。目前在 OpenRouter 的全球 Token 使用量排名中位列第一。
这正是过去几周我用来构建全部营销运营的框架，而这篇文章正是如果我今天要开始搭建它时我会采取的方式。
## 你将从本文中获得什么
- Hermes 代理是什么，以及为什么营销人员（不仅仅是开发者）应该关注它
- 架构的通俗版：大脑、性格、技能集，以及它们如何共存于一个文件夹中
- 我个人在 Hermes 上运行的用例，以及我为此发布的四篇相关文章
- 四部分思维模型（你、控制室、代理、可选的任务总线）和四个级别的设置，从“你笔记本电脑上的一个代理”到“你用手机控制的、运行在 VPS 上的全自动代理团队”
- 我将营销工作流从混乱的想法转化为自主部署所使用的原型→生产方法论
- 我希望在第一天就能拥有的资源：文档、社区地图、值得关注的人、正在举行的聚会
- 真实的权衡以及它目前仍然存在的缺陷
我在本文中不向你推销任何东西。Hermes 是开源的，Nous Portal 有免费套餐，社区生态系统的大部分也是免费的。Fork、修改、让它成为你自己的工具。
## Hermes 代理是什么
简短版：一个运行时间越长能力越强的自主代理。
更长版：Hermes 是由 Nous Research 构建的框架，它将一个模型转变为持久的操作员。它拥有在会话之间持久保存的内存。它在工作时编写自己的技能。它附带了 123 个内置技能（GitHub 工作流、Obsidian、Google Workspace、Linear、Notion、Typefully、Perplexity、深度研究，外加 100 多种其他技能）。它居住在你放置的任何地方：你的笔记本电脑、Docker 容器、VPS、无服务器运行时。你可以通过 20 多种界面与它对话：Telegram、Discord、Slack、电子邮件、语音模式，或者仅仅是你的终端。
> **Shann³@shannholmberg**: [原文链接](https://x.com/shannholmberg/status/2054249815291351207)
>
> Hermes Agent 改变了我的工作方式
> 它是你目前可以设置的最高效用的代理框架
> 它的不同之处在于：
> > 它根据复杂度和成本将任务路由到正确的模型
> > 随着时间推移学习你的声音和偏好
> > 处理上下文切换而无需……
>
> 
> 
如果你使用过 Claude Code 或 OpenClaw，Hermes 形状相似但哲学不同。
> Hermes 是 Rails。固执的默认设置，自带电池，极少的设置即可在第一天提高生产力，代理为你做更多的思考。
> OpenClaw 是 Linux。原语、保证、显式控制，代理完全按照你告诉它的去做，不多也不少。
两者都是有效的。我运行 Hermes 是因为捆绑的默认设置会产生复利效应。我用 Hermes 开始的每个项目，在我编写一行配置之前，代理就已经知道如何做 100 多件事。这种先发优势对我来说是值得的。我也注意到，Hermes 没有那种网关断开连接或出 Bug 的同样问题。
证明在于 Nous Research 刚刚达成的数据：
- 在 OpenRouter 的全球 Token 使用量中排名第一（在平台上的所有模型和框架中）
- Hermes 仓库拥有 15 万 GitHub 星标
- 在代理编写自己的技能之前有 123 个捆绑技能
- 网关中有 70 多个内置工具，外加通过一个订阅可用的 300 多个模型
- 6 个部署目标：本地、Docker、SSH、Daytona、Singularity、Modal
- 20 多个消息界面：Telegram、Discord、Slack、电子邮件、语音
如果你是一名 AI 营销人员，并且还没有开始运行 Hermes，那么你每周都在把复利能力留在桌面上。
## 它是如何工作的（通俗版）
每个 Hermes 代理都有三样东西。
一个大脑。内存位于 ~/.hermes/memories/。两个文件，MEMORY.md 和 USER.md，在会话开始时注入。你的声音标准、你的品牌笔记、你的客户语言、上周的修正，所有这些都在第一个提示之前加载。会话存储在 sqlite 中，跨会话的召回是全文可搜索的。
一个性格。soul.md 是氛围所在的地方。简洁。讽刺。直率。正式。快速或深思熟虑。你可以启动六个代理，给每个一个不同的灵魂，下面是同一个大脑。一个是你的具有成交能量的外展代表。另一个是喜欢长句子的研究员。另一个是保持一切简短的助手。
## 一个技能集。
开箱即用的 123 个技能：GitHub PR、Obsidian、Google Workspace、Linear、Notion、Typefully、Perplexity、深度研究、浏览器控制、网页抓取、视觉、语音、调度。以及闭环学习：随着代理的工作，它会沿途编写新技能。你自己的技能库在 123 个技能的基础上增长，而无需你编写任何代码。
然后是代理可以与之对话的东西。
- 工具网关：一个订阅，300 多个模型，外加内置的网页抓取和浏览器自动化
- MCP 集成：任何讲 Model Context Protocol 的外部服务都成为你的代理可以使用的工具
- 20 多个消息界面：Telegram、Discord、Slack、电子邮件、语音，外加 CLI 本身
以及代理可以居住的地方。
- 你的笔记本电脑（本地）
- 一个 Docker 容器（隔离、便携，这是我运行它的方式）
- VPS 上的 SSH 会话（这样即使你的笔记本电脑合上它也会运行）
- Daytona、Singularity、Modal（如果你不想管理基础设施，则是无服务器的）
闭环学习是使其不同于智能聊天机器人的原因。代理观察自己的工作，在学习工作形状时编写新技能，定期完善其内存，并使用全文搜索和 LLM 摘要的混合来召回过去的上下文。你不必下周重新教它。
> 我告诉 Hermes 新手的规则是这样的：
> 不要试图在第一天编写自己的技能。运行真实的工作，让代理观察，让工具链编写技能。通过工作比通过编写提示词能更快地构建自定义技能库。
## 我在 Hermes 上运行的东西
我是一名 AI 营销人员，不是程序员。我在 Hermes 上运行的大部分是营销基础设施，偶尔有内部工具。这是实际的清单：
- 一个处理业务和私事的个人助理，生活在 Telegram 中，每天早上标记四封值得阅读的电子邮件，安排我的提醒，总结我错过的会议
- 一个营销工作流原型台，我在这里针对真实工作测试新流程（潜在客户磁铁、广告创意审查、内容冲刺），在将它们推广之前运行 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. company brain - 愿景、品牌、客户、产品。其他层继承的上下文
> 2. orchestrator 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 代理：获取主题或关键词种子并将其路由到 SEO 代理
3. SEO 大脑：排名手册、声音规则、内容格式、视觉风格指南、每种格式的成功标准。所有特定的 SEO 上下文都在这里
4. SEO 代理内的三个子代理，每个处理一个阶段：
5. research + ideate：关键词种子、SERP 快照、竞争对手提取、意图和格式分析、内容和视觉差距、内部和外部验证
6. production：角度和定位简报、视觉策略简报、大纲、草稿、图像生成、流程图生成、视觉和文章 QA
7. distribution：发布准备、Schema、内部链接、联合发布、分析、监控
8. 一个 Docker 容器容纳所有三个子代理。它们共享环境、内存和工具。子配置文件在每个阶段切换上下文。一个进程、一个文件系统、一组凭据。
为什么是一个容器而不是三个：SEO 工作是顺序的。研究输入简报，简报输入生产，生产输入分发。每一步都需要对上游决定内容的记忆。拆分为三个容器意味着跨边界穿梭状态，这既昂贵又会破坏链条。
公司里的每一个其他专业代理都运行在相同的模板上。克隆 SEO 代理模板，交换大脑（SEO 大脑 → 外展大脑，或 → 设计大脑，或 → 支持大脑），你就拥有了一个具有相同五层形状的任何功能的新代理。
> **Shann³@shannholmberg**: [原文链接](https://x.com/shannholmberg/status/2054958228149342621)
>
> 我的 hermes seo 代理如何在组织架构图中工作
> 它运行从关键词种子到已发布文章的完整管道，21 个步骤，都在一个 docker 容器内
> 结构：
> LAYER 1: company brain
> 共享上下文：愿景、品牌、受众、产品。每个代理都从这里读取
>
> 
> 
> 层级不是装饰。它们是代理在工作变得专业化时不丢失上下文的原因。当工作者迭代时，公司大脑保持稳定。大脑层级使工作者可被丢弃。
最近，我还在里斯本的 @EspressioAI 总部为 Hermes Agent 举办了一个 Nous Research 晚间活动。来自 Nous 的 @yeahfortommy 主持了问答环节，来自 noticed .so 的 Simao 展示了一个带有自动研究的代理工具链，我介绍了我们在 Espressio 如何使用 Hermes 进行增长。
> **Shann³@shannholmberg**: [原文链接](https://x.com/shannholmberg/status/2048747512006324527)
>
> 明天我们将在 Espressio HQ 为 Hermes Agent 晚间活动招待 @NousResearch
> @touchgrassklub 正在与 Talent Protocol 合作组织
> 晚间议程如下：
> > 我将首先谈谈使用 Hermes Agent 进行增长，我们正在发布……
>
> 
> 
如果你在里斯本并且想参加下一次，我会在安排好时发布信息。
## 从一个代理到完整的舰队
在介绍级别之前，先介绍思维模型。
该设置有四个部分：
- 你是操作员。你可以直接访问系统的每个部分。
- 代理控制室是侧控制平面。它不是一个你通过聊天的代理。它是位于 /root/vps-agents 的一个文件夹，用于记录和管理整个舰队。你打开它、编辑它、检查它，或者在管理系统时要求 claude、codex 或 hermes 使用它。
- Hermes 代理是工作者。有些是专家（SEO、开发、CMO、运营）。其中之一可以是编排器。
- 代理任务总线是一个可选的交接台，位于编排器和专家之间。只有当你启用了编排器时才需要它。
整个看起来像这样：
```
┌───────┐
│ 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.
```
存储的划分比人们……