我把 Hermes 这匹"马"养了两周，它干了一件让我有点发毛的事
先交代下背景。我是做后端开发的，十余年后端开发经验，平时跟各种 AI 编码工具打交道，Cursor、Claude Code 都玩过。前阵子不是圈子里都在聊"养虾"（OpenClaw），折腾一圈后，没啥实际应用。风声过后，“马”又出来了，我跟风去试了 Hermes。国内大家都叫它"贵族马"，因为图标是个带翅膀的马头，还挺好记。
这个用了一阵子，别的没太觉得惊艳。直到有天晚上我改一个老项目的 bug，顺手让它"记一下这个坑"，然后就睡了。第二天早上我还没开口，它就把昨天那个坑的解决步骤，原封不动地按在了新会话的开头。
我当时心里就咯噔一下。
这不是记性好的问题。这是它自己给自己写了份操作手册，而且写的比我以前在 wiki 上记的还清楚。
此时才发现贵族马的这套 skill 系统，是我觉得最被低估的一块。今天不吹不黑，就聊聊这个。
先说个我之前一直搞错的事
我一直以为"自我进化"听起来就很玄，以为是那种会自己微调权重、偷偷变聪明的东西。看名字我也怕——"self-improving"，这词在 AI 圈被用烂了，十个产品九个拿它当噱头。
结果 Hermes 这个，朴素的有点让人失望。
它的逻辑就一句话：学到一条值得记的经验，就把它写成一个 Markdown 文件，存硬盘上，下次读。
没微调。没训练。模型参数一次没动。
我后来想了个比方，可能不太准但好懂：它不是学会了游泳，它是把游泳教程抄在了笔记本上，下次下水直接翻。教程越抄越多，但它本人还是那个它。
（说到这你可能觉得"就这？"——别急，后面才是重点。）
它记的到底是啥
Hermes 把"记忆"分了三块，我刚看的时候觉得这分类有点东西，因为它跟我脑子的工作方式还真有点像：
- 一块叫 Memory，记"你是个啥样的人、喜欢啥"——比如我给它记过"这用户讨厌在 shell 里用 cat，让他用 Read"。这种每次聊天开头就加载。
- 一块叫 Session Search，记"咱俩之前聊过啥"——历史对话，用 SQLite 加全文检索，想起来了去翻。
- 第三块才是 skill，记"这活儿怎么干"——步骤、命令、坑、怎么验证。
前两块别的 agent 也有，差不太多。真正不一样的是第三块：它记的不是"发生了什么"，是"怎么做才对"。
我给你看一个真实长啥样的技能文件（这是我让它从 test-driven-development 那个官方技能里扒的）：
---
name: test-driven-development
description: Use when implementing any feature or bugfix,
before writing implementation code.
version: 1.1.0
author: Hermes Agent (adapted from obra/superpowers)
---
# When to Use
实现任何功能或修 bug 之前。
# Procedure
RED-GREEN-REFACTOR：先写会失败的测试，再写最小实现让其通过，最后重构。
# Pitfalls
不要先写实现再补测试——那是本末倒置。
# Verification
测试全绿、覆盖率不降。
你看那个 description 字段没？它不是写给人看的，是写给"技能选择器"看的触发词。写的越准，下次该用它的时候越靠谱。而正文记的全是教训，不是流水账——一条坑，是一条能复用的规则加一句"为什么别这么干"，而不是"那天下午 PR #1234 挂了"。
这点我挺服的。我自己记笔记从来记成流水账，回头根本不想看。
它是怎么"长"出来的
这块我花了点时间才搞明白，因为官方文档写的挺绕的。简单说是个闭环：
什么时候写？ 系统提示里要求它，遇到这几种情况就得把流程存成技能：把一件复杂的事干成了（大概花了 5 次以上工具调用）、撞墙了又绕过去的、被我纠正了做法的、或者发现一个不寻常的工作流。
写完谁来看？ 每轮对话结束，Hermes 会 fork 一个"安静模式"的副本，不吵你，专门复盘刚才那轮：用户有没有透露啥长期有用的偏好？我们是不是执行了个又复杂又成功的多步流程、值得固化一下？这其实就是 AI 圈那个有名的 Reflexion（反思）范式，被他们做成默认开着的后台线程了。嫌吵也能关，改手动 /refine。
最关键的一个设计——渐进式披露。 我一开始最担心的是：技能越攒越多，上下文不就爆了？我电脑上跑别的 agent 就经常暴。Hermes 的解法是分层加载，这个我得夸一下，想的真细：
- Level 0：系统提示里只放每个技能的名字加一句话简介，总共大盖就 3k token，永远在那；
- Level 1：判断这次用得上，才用 skill_view 把完整内容读进来；
- Level 2：要细节了，再单独读某个参考文件。
好处是啥呢——技能从 10 个涨到几百个，你每一轮花的 token 几乎没涨。它用"按需展开"，把"经验多"和"每次都便宜"这两件本来矛盾的事，同时做到了。这个我反正是没想到，挺妙的。
还有一个叫 "Curator"（策展人）的角色，专门负责"忘事"：长期不用的技能会被标旧、然后归档；可选的还能把重复的合并。它不清删，带备份能回滚。连"忘记"都被他们显式设计进去了，这点我之前真没注意。
为啥非得是 Markdown，而不是去动模型
我一开始也纳闷，为啥不直接微调让它变聪明。后来看他们一个开发者的访谈才想通。
技能文件必须人能读、能审、能 diff、能搬走。它遵循 agentskills.io 那个开放标准，意思就是你给 Hermes 写的技能，理论上能拿到别的兼容 agent 上用，不被锁死在某一家。
再深一层，它把"学习"变成了一个 git 能管的文本文件。我可以直接 review 它新写的每条技能，就跟 review 同事的 PR 一样。放在公司里，这比"模型偷偷变了"要让人放心的多。我老板要是知道有个 AI 在偷偷改自己，估计当场就给禁了。
说点真话：这玩意也有坑
我不能光夸，用下来确实有代价，这几条你最好知道：
一个是费 token。自我改进的循环每次会多耗大概 15% 到 25% 的 token（这是第三方测的，不是我瞎说）。我那台开发机跑一周下来，账单比平时厚了点。
第二个更烦——它会记错。默认情况下写审批是关的，也就是它"随便写"。有一回它给我记了个错的流程，还是被我之前一个测试脚本里的注释带偏的，结果后面两天老犯同样的错，我调了半天才发现是它记岔了。所以我的建议是，只要联网或者长开着的，把 skills.write_approval 和 memory.write_approval 都打开，让它写之前先问你。
第三个，也是最容易让人误会的："说了记不住"其实是设计好的。记忆是会话开始时拍的快照，你这轮让它记的东西，得等下个会话才生效。我一开始还以为是 bug，跑去提 issue，人家说这是为了保前缀缓存故意的。
所以你看，Hermes 给你的是个会自己攒经验的"同事"，但就像真同事一样，你得给他立规矩、做 code review。不能全信。
我的一点个人想法
扯远点说。普通 chatbot 每次都从零开始，像个永远记不住脸的柜员。Hermes 是在攒"资本"，它的经验是复利的。
我有时候想，人也是靠程序性记忆，把重复的动作变成本能；Hermes 靠技能系统，把重复的任务变成 SOP。本质上是一回事：把一次性的劳动，沉淀成能复用的东西。
我养这匹"马"一段时间，最深的感受不是它多聪明，而是它真的在"长"。不是模型变聪明那种长，是它身边的笔记本越来越厚。
有次我跟朋友老王说这个，他回我一句："你这不是在养 AI，你是在养一个会自己整理书架的图书管员。"我觉得他说的挺准的，虽然"图书管员"这词他念错了，但意思到了。
所以回到开头那个发毛的感觉——我现在不那么怕了，反而有点期待。未来 agent 之间比的，可能真不是某一次谁更聪明，而是谁的 agent 攒下的靠谱 SOP 最多、最准。
你会放心把"写技能、记记忆"的权限完全交给它吗？还是一定要加一道人工审批？反正我现在是开着审批的，有点怂。评论区聊聊？
本文由 AI图鉴自动抓取并翻译，版权归原作者所有；如需查看原文请点下方链接。
I raised this horse for two weeks. It made me a little hairy. Yes.
I'll give you the background. I'm doing back-end development, over 10 years later, dealing with a variety of AI coding tools, Cursor, Claude Code. It wasn't all about OpenClaw a while ago, and there wasn't much practical use. After the wind, the horse came out, and I went with the wind to test Hermes. It's called "Nobility Horse" in the country, because it's a winged horsehead. It's a good memory.
It's been a while. It's not too amazing. Until one night I changed the old project bug to "Remember this pit" and then fell asleep. The next morning, before I opened my mouth, it pressed the settlement of yesterday's pit to the beginning of the new session.
I had a little bit of a tick in my heart.
It's not about memory. It wrote itself an operating manual, and it was clearer than I had written on wiki.
It's only at this point that the noble horse's skill system is the one I feel most underestimated. Let's talk about this.
Let's start with something I've been wrong about.
I always thought "self-evolution" sounded like something that could fine-tune its weight and get smart. I'm afraid of the name -- "self-improven," the word used in the AI circle, 10 products and nine products.
Turns out Hermes is a little disappointing about this.
Its logic is one thing: to learn a memorable experience, to write it into a Markdown file, to put it on hard drive, to read it next time.
No fine-tuning. No training. Model parameters remain intact at once.
And I thought of an example, which might not be quite clear, but it understood it: it didn't learn to swim, it copied the swimming tutorial on the notebook, and next time it went into the water. The more the curriculum goes, the more it is.
"That's it?"
What does it remember?
Hermes split "remember" into three pieces, and I thought there was something in the classification because it was a little bit like the way my head works:
- One by memory, "What are you, what do you like?" - Like I wrote to it, "The user hates to use cat in shell and let him use Read." This kind of chat starts with a load.
- One by the name of Ssession Search, "What did we talk about before"? - History conversation, full-text search with SQLite.
- The third is Skill, remember, "How does this work?" Steps, orders, pits, how to verify.
The first two other angents have, not too bad. The real difference is the third: it's not "what happened," it's "what's right."
I'll show you a real skill file.
---
name: test-driven-development
description: Use when implementing any feature or bugfix,
before writing implementation code.
version: 1.1.0
author: Hermes Agent (adapted from obra/superpowers)
---
# When to Use
Before any functionality or bug repair is achieved.
# Procedure
RED-GREEN-REFACTOR: Write first the failed test, then write the minimum achievement for its passage, and eventually recreate.
# Pitfalls
And don't write the test first -- that's a reverse.
# Verification
Tests are green and coverage is constant.
Did you see that field? It's not written for people, it's written for the Skills Selector. The more accurate it is, the better it is next time. And it's all a lesson, not a trick -- a pit, a reusable rule, plus "Why don't you do it" instead of "Pr #1234 died that afternoon."
I'm impressed with that. I took my own notes and never wanted to read them.
How did it grow?
It took me a while to figure this out, because the official documents are kind of cluttered. In short, it's a closed circle:
The system hint requires it to be skilled in these situations: It's a complicated thing to do (about five or more times tool call), to hit the wall and go around, to be corrected by me, or to find an unusual workflow.
At the end of each conversation, Hermes will fork a copy of the quiet mode, not to bother you, to replay that round: Did the user reveal any long-term useful preferences? Have we implemented a complex and successful multi-step process that deserves to be solidified? It's actually the famous Reflexion model of AI, which they're doing as a default backstage. You can turn off the noise and change your hands.
One of the most critical designs — progressive disclosure. What I was worried about at the beginning was that the more skills I gained, the more context went off. My computer runs other agents all the time. Hermes' solution is a layered load, which I'd like to exaggerate.
- Level 0: Only the name of each skill is added to the system alert, and the total cap is 3k token, always there;
- Level 1: It's only this time that you can read the whole story in the skill view;
- Level 2: Read a single reference document for details.
What's the benefit -- skills have risen from 10 to hundreds, and your tokens have barely risen. It uses "speech on demand" to put "experienced" and "cheap every time" in conflict, and it does. Well, I didn't think of that anyway. That's good.
There is also a role called "Curator," which is dedicated to "forget things": skills that are not used for a long time will be pasted and then archived; options can also combine duplicates. It's not clear. The backup can roll back. Even Forget was designed by them. I didn't notice that before.
Why do you have to be Mark Down instead of moving the model?
I was wondering at first why you didn't just fine-tune it to make it smart. It was only after an interview with one of their developers.
Skills documents must be readable, trialable, diffable and moveable. It follows the open standard, which means that you give Hermes the skills to write, theoretically get another compatible agent, not be locked in a certain home.
And deep down, it turns "learning" into a text file that you can manage. I can directly review every skill it's written, just like the PR of a review colleague. In the company, it's more reassuring than "silent model." If my boss knew there was an AI in the middle of sneaking around, he'd probably be grounded on the spot.
Tell the truth: There's a hole in this thing.
I can't exaggerate. There's a price. You better know these:
One is token. The self-improvement cycle takes about 15 to 25 percent of the token each time. My developer runs down a week, billing a little more than usual.
The second is more annoying -- it'll be wrong. By default, write clearance is off, which means it's "script." One time it gave me the wrong process, or it was led by a note from my previous test script, and then I made the same mistake for the next two days, and I changed it half a day to find it confusing. So what I suggest is, as long as it's connected or open, turn on the skills.write approval and memory.write approval before it's written.
The third, and the most misleading, is that it's actually designed. The memory is a snapshot taken at the beginning of the session, and you have to wait for the next session to take effect. At first I thought it was a bug and ran to mention the issue, which was said to be intended to protect the prefix cache.
So you see, Hermes gives you a "coworker" who can save his own experience, but like a true colleague, you have to set him up rules and do code review. Can't believe it all.
I have a few personal thoughts.
Shut up. Normal chatbot starts from scratch, like a cabinetman who can never remember his face. Hermes is saving "capital," and its experience is compounding.
Sometimes I think people rely on procedural memory to turn repetitive moves into instincts; Hermes rely on skill systems to turn duplicate tasks into SOPs. Essentially, it's one thing to put one-time labor, to sink into something that can be used again.
I raised this horse for a while, and the deepest feeling was not how smart it was, but how long it really was. It's not the model that gets smarter, it's the notebook that gets thicker.
One time I said this to my friend Wang, he said to me, "You're not raising AI, you're raising a bookkeeper who'll make his own bookshelf." I think he's quite right, although he's wrong about the word "librator," but he means it.
So back to that hairy feeling at the beginning -- I'm not so scared now, I'm looking forward to it. The future between parties may not really be who's smarter, but who's the one who's got the best, best SOP.
Would you give it all to write skills, memory? Or do we have to add manual clearance? I'm working on it. It's a little awkward. A comment section?
Auto-fetched and translated by AI Atlas. All rights belong to the original author.