你教了 AI 助手一整套部署流程,对话关掉,第二天它全忘了。你又教了一遍。第三天,继续忘。
几乎所有 Agent 产品都卡在同一个死穴上——无状态。每次对话从零开始,上下文窗口一清,什么都不剩。
6 月 23 日,开源 AI 实验室 Nous Research 给出了一个相当暴力的解法。
一行命令,把资料炼成技能
Nous Research 官方账号发帖宣布:Hermes Agent 新增/learn命令。
"Hermes Agent can now /learn from anything: feed it directories of any source material (code, API docs, manuals, PDFs, configs) and it distills a verifiable reusable skill"
「Hermes Agent 现在可以从任何来源 /learn:给它任何源材料目录(代码、API 文档、手册、PDF、配置文件),它就能提炼出可验证、可复用的技能。」
▲ Nous Research 官方公告,95 万+浏览量
注意用词:distills(蒸馏/提炼)。
它做的事情比"存档"狠得多——把原始材料压缩、重组、结构化,输出一份带步骤、带验证方法、带踩坑记录的「技能手册」,格式标准,可以直接当命令调用。
联合创始人 Teknium 紧接着补了一条更口语化的解释:
"Hermes can now LEARN from any source or set of sources, build a skill, test it live, and crystallize new learnings."
「Hermes 现在可以从任何来源集合中学习,构建技能、实时测试并固化新知识。」
▲ Teknium 强调三个关键动作:构建、实时测试、固化
三个动词划出了完整链路:build → test → crystallize。学完不算完,还要当场跑一遍,确认能用,才写进技能库。
/learn 的四种「喂法」和六步流程
Teknium 同步放出了一张流程信息图,把 /learn 的工作机制拆得非常直观。
▲ Teknium 配图:"Time to get to school, Hermes"——该上学了
四种输入方式,覆盖几乎所有你能想到的资料形态:
- 本地目录:代码仓库、API 文档、手册、PDF、配置文件,直接指路径
- 在线 URL:文档链接、教程页面,agent 自己去抓
- 刚做完的对话:上一轮你手把手教它的工作流,直接固化
- 粘贴的笔记:随手记的操作步骤、口头描述的流程
六步执行链路:
- 用户输入
/learn+ 描述 + 来源 - Agent 用内置工具(read_file、search_files、web_extract)自动采集材料
- 按标准格式生成 SKILL.md:包含使用场景、执行步骤、已知踩坑、验证方法
- 通过 skill_manage 工具存入
~/.hermes/skills/ - 零新增模型工具——完全复用现有能力
- 实时测试通过才算完成
最后一步才是关键:它不是"存了就算了",它会当场运行生成的技能,跑通了才固化。相当于学完知识点还要当场考试,考过了才写进长期记忆。
官方文档里给了几个典型调用示例:
/learn the REST client in ~/projects/acme-sdk, focus on auth + pagination /learn https://docs.example.com/api/quickstart /learn how I just deployed the staging server /learn filing an expense: open the portal, New > Expense, attach the receipt, submit 从技术文档到报销流程,都能学。
技能到底长什么样?
学完之后,生成的技能会存在~/.hermes/skills/目录下,每个技能一个 SKILL.md 文件,格式严格统一:
--- name: my-skill description: 60 字以内简述 version: 1.0.0 --- ## When to Use(什么时候用) ## Procedure(步骤) ## Pitfalls(踩坑记录) ## Verification(怎么确认成功) 四个板块,覆盖了从"什么时候触发"到"怎么验证结果"的完整闭环。
调用更简单——直接打/技能名就行,和内置命令一样。agent 在执行任务时,如果判断某个技能相关,也会自动加载。
▲ Hermes 官方文档页,/learn 是技能系统的快速入口
这套架构有一个精巧的设计:渐进式加载(Progressive Disclosure)。
- Level 0:只返回技能的名字和描述(几十个 token)
- Level 1:需要时才加载完整技能内容
- Level 2:按需读取子文件
技能再多也不会撑爆上下文。日常对话时,agent 只知道"我有哪些技能";真正用到某个技能,才把详细步骤拉进来。
比 RAG 多走了一步
熟悉 AI 工具链的读者可能会问:这和 RAG(检索增强生成)有什么区别?
RAG 做的事情是"找到相关片段,塞进 prompt"。你问一个问题,它去知识库里翻,翻到了就贴上来。好用,但有局限——它只帮你查,不帮你干。
/learn 生成的技能包含了完整的操作流程、验证方法和踩坑记录。RAG 给你一张地图的碎片,技能给你一套经过验证的导航路线。
而且技能是"过程记忆"(procedural memory),记的是how——怎么一步步完成任务。普通的文本检索是"事实记忆"(declarative memory),记的是what——某个事实是什么。
这个区别很大。你背下了自行车的结构图(事实记忆),不代表你会骑车。/learn 想做的是让 agent 真正"学会骑车"。
社区已经玩疯了
公告发出几个小时内,社区的测试帖像井喷一样涌出来。
X 用户 @witcheer 整理了一份实用指南,总结了四种输入方式,还特别提醒:
"the skill lands in ~/.hermes/skills/ and auto-loads only when a task calls for it, so it's procedural memory that doesn't bloat every prompt"
「技能落在 ~/.hermes/skills/,只在任务需要时自动加载,所以它是过程记忆,不会让每个 prompt 都膨胀。」
▲ witcheer 的 Hermes 技巧帖,强调"用完不膨胀"
更猛的案例来自其他用户:
有人把4GB 的教科书喂了进去——覆盖各种科学领域——然后说自己的 Hermes Agent "在诊断方面比一些前沿模型还强"。
"I converted over 4GB of textbooks on every science... My Hermes Agent is better at diagnostics than some frontier models."
有人让它学了整个代码仓库:
"Hermes learned my entire repo in minutes... Files. Patterns. Architecture. Commands. Workflows. It created a playbook."
「Hermes 几分钟就学完了我整个仓库……文件、模式、架构、命令、工作流。它自己创建了一本 playbook。」
甚至有人问:能学 YouTube 视频吗?回答是:可以。
在 /learn 之前,用户要让 Hermes 掌握特定领域知识,得手动喂 GitHub 仓库或目录,写复杂的 prompt 来引导。现在一行命令搞定。难怪有人评论说:
"i like that you've wrapped it into a /learn command. slick way to make a new skill."
「我喜欢你们把它封装成了 /learn 命令。创建新技能的方式太顺滑了。」
"越用越聪明"的闭环
退一步看整个 Hermes Agent 的产品逻辑,/learn 绝对不是一个孤立的功能。
▲ Hermes 官网首页标语:"THE AGENT THAT GROWS WITH YOU"——和你一起成长的 Agent
Hermes 的核心设计思路就是持久化 + 自我进化:
- 持久记忆:MEMORY.md + USER.md 记录关键事实和用户画像,故意限容,强迫浓缩
- 全历史检索:SQLite + FTS5,本地全文搜索所有对话记录
- 技能系统:成功的工作流自动固化成技能,下次直接调用
- 学习循环:执行 → 评估 → 提炼技能 → 下次更好
- 后台 Curator:自动整理、优化、清理技能库
/learn 在这套体系里的角色很明确:把外部知识注入这个闭环的快速通道。
以前 agent 只能从自己的执行经验中学习——做过一次复杂部署,成功了,自动写成技能。现在它可以从别人的经验中学——你的教科书、你同事的文档、开源项目的代码、网上的教程。
等于说它获得了"间接经验学习"的能力。
而且这一切都是本地运行的。数据默认存在你的机器上,支持 CLI、桌面应用(macOS/Windows/Linux)、Telegram/Discord/Slack 等消息网关,甚至可以部署到 VPS、Docker、Modal 上 24/7 运行。MIT 开源协议。
GitHub 上的 star 数在 2026 年持续飙升,已经突破 20 万。社区不止一次把它称为"开源 Agent 里增长最猛的项目"。
当 Agent 开始积累经验
回到最开始的问题:你教 AI 助手的东西,为什么总是记不住?
因为大多数 AI 产品的架构根本就没有"学习"这个概念。对话结束,上下文清空,下一轮从头来过。充其量给你一个检索增强,让你能搜到过去的对话片段——但那和"学会"是两码事。
Hermes 做的事情,是在 Agent 的执行层面引入了一套完整的知识生命周期:获取 → 提炼 → 测试 → 固化 → 按需调用 → 持续优化。
/learn 把这个循环的入口拉到了极低的门槛:任何资料,一行命令。
当 Agent 可以像人一样积累经验、沉淀方法论、越干越熟练——"AI 助手"和"AI 同事"之间的那条线,可能比我们想象的要模糊得多。
You teach an AI assistant an entire deployment workflow, close the chat, and the next day it has forgotten everything. You teach it again. On the third day, it forgets again.
Nearly all Agent products hit the same bottleneck—statelessness. Every conversation starts from scratch; clear the context window and nothing remains.
On June 23, open-source AI lab Nous Research delivered a rather aggressive solution.
One command to forge knowledge into skills.
The official Nous Research account announced: Hermes Agent adds the /learn command.
"Hermes Agent can now /learn from anything: feed it directories of any source material (code, API docs, manuals, PDFs, configs) and it distills a verifiable reusable skill"
"Hermes Agent can now /learn from anything: feed it directories of any source material (code, API docs, manuals, PDFs, configs), and it distills a verifiable, reusable skill."
▲ Nous Research official announcement, 950K+ views
Note the word choice: distills.
What it does is far more aggressive than "saving"—it compresses, reorganizes, and structures raw materials into a "skill manual" with steps, verification methods, and known pitfalls, in a standardized format that can be called directly as a command.
Co-founder Teknium immediately followed up with a more conversational explanation:
"Hermes can now LEARN from any source or set of sources, build a skill, test it live, and crystallize new learnings."
"Hermes can now learn from any source collection, build skills, test in real-time, and crystallize new knowledge."
▲ Teknium emphasizes three key actions: build, test in real-time, crystallize
The three verbs define the complete pipeline: build → test → crystallize. Learning isn't finished just by absorbing—it must run once on the spot, confirm it works, then write into the skill library.
Four ways to feed /learn and the six-step process
Teknium simultaneously released a flow diagram, breaking down the /learn mechanism very intuitively.
▲ Teknium's illustration: "Time to get to school, Hermes"—time to learn
Four input methods, covering almost every form of material you can imagine:
Local directory: code repos, API docs, manuals, PDFs, config files, just point to the path
Online URL: document links, tutorial pages, the agent goes to fetch itself
Recent conversation: the workflow you hand-held taught it last round, solidify directly
Pasted notes: randomly jotted operation steps, verbally described processes
Six-step execution chain:
User inputs /learn + description + source
Agent uses built-in tools (read_file, search_files, web_extract) to automatically collect materials
Generates SKILL.md in standard format: includes use cases, execution steps, known pitfalls, verification methods
Stores via skill_manage tool into ~/.hermes/skills/
Zero new model tools—completely reuses existing capabilities
Real-time test pass = completion
The final step is the key: it doesn't "save and forget"—it runs the generated skill on the spot. Only after it passes does it crystallize. Like finishing a lesson and taking an exam immediately; only if you pass do you write it into long-term memory.
The official docs give several typical call examples:
From technical docs to reimbursement processes, everything can be learned.
What exactly does a skill look like?
After learning, generated skills are stored in the ~/.hermes/skills/ directory, one SKILL.md file per skill, strictly unified format:
Four sections covering the complete loop from "when to trigger" to "how to verify results."
Calling is simpler—just type /skillname, same as built-in commands. When the agent judges a skill is related during task execution, it auto-loads.
▲ Hermes official docs page, /learn is the quick entry to the skill system
This architecture has an elegant design: progressive disclosure.
Level 0: returns only skill names and descriptions (dozens of tokens)
Level 1: loads full skill content only when needed
Level 2: reads sub-files on demand
No matter how many skills, the context won't explode. In daily conversations, the agent only knows "what skills I have"; only when actually using a skill does it pull in the detailed steps.
One step beyond RAG
Readers familiar with AI toolchains might ask: what's the difference between this and RAG (Retrieval-Augmented Generation)?
RAG's job is "find relevant snippets, stuff them into the prompt." You ask a question, it searches the knowledge base, and pastes what it finds. Useful, but limited—it only helps you look things up, not do things.
Skills generated by /learn contain complete operation flows, verification methods, and pitfall records. RAG gives you fragments of a map; skills give you a verified navigation route.
And skills are "procedural memory," recording how—how to complete a task step by step. Ordinary text retrieval is "declarative memory," recording what—what a certain fact is.
This distinction matters a lot. Memorizing a bicycle's structure diagram (declarative memory) doesn't mean you can ride. /learn aims to let agents truly "learn to ride."
The community has gone wild
Within hours of the announcement, community test posts flooded in like a geyser.
X user @witcheer compiled a practical guide summarizing the four input methods, and specifically warned:
"the skill lands in ~/.hermes/skills/ and auto-loads only when a task calls for it, so it's procedural memory that doesn't bloat every prompt"
"The skill lands in ~/.hermes/skills/ and only auto-loads when a task requires it, so it's procedural memory that doesn't bloat every prompt."
▲ witcheer's Hermes tips post, emphasizing "use without bloat"
More impressive cases from other users:
Someone fed in 4GB of textbooks—covering all scientific fields—and said their Hermes Agent is "better at diagnostics than some frontier models."
"I converted over 4GB of textbooks on every science... My Hermes Agent is better at diagnostics than some frontier models."
Someone had it learn an entire code repository:
"Hermes learned my entire repo in minutes... Files. Patterns. Architecture. Commands. Workflows. It created a playbook."
"Hermes learned my entire repo in minutes... Files, patterns, architecture, commands, workflows. It created a playbook."
Someone even asked: can it learn from YouTube videos? The answer: yes.
Before /learn, users had to manually feed Hermes specific domain knowledge by feeding GitHub repos or directories, writing complex prompts to guide it. Now one command does it. No wonder someone commented:
"i like that you've wrapped it into a /learn command. slick way to make a new skill."
"I like that you've wrapped it into a /learn command. Such a smooth way to create new skills."
The "gets smarter with use" closed loop
Stepping back to look at the overall Hermes Agent product logic, /learn is absolutely not an isolated feature.
▲ Hermes official website homepage slogan: "THE AGENT THAT GROWS WITH YOU"
Hermes's core design philosophy is persistence + self-evolution:
Persistent memory: MEMORY.md + USER.md record key facts and user profiles, intentionally capacity-limited to force compression
Full history retrieval: SQLite + FTS5, local full-text search across all conversation records
Skill system: successful workflows automatically solidify into skills, called directly next time
Learning loop: execute → evaluate → distill skills → perform better next time
Background curator: automatically organizes, optimizes, and cleans the skill library
/learn's role in this system is clear: the fast channel to inject external knowledge into this closed loop.
Previously agents could only learn from their own execution experience—after a complex deployment succeeded once, it automatically wrote a skill. Now they can learn from others' experiences—your textbooks, your colleague's docs, open-source project code, online tutorials.
It's as if they've gained the ability to learn through "indirect experience."
And all of this runs locally. Data stores on your machine by default, supporting CLI, desktop apps (macOS/Windows/Linux), Telegram/Discord/Slack message gateways, and can even deploy to VPS, Docker, Modal for 24/7 operation. MIT open-source license.
The GitHub star count has been soaring continuously since 2026, already breaking 200K. The community has called it "the fastest-growing open-source Agent project" more than once.
When agents start accumulating experience
Back to the original question: why can't your AI assistant remember what you taught it?
Because most AI products' architectures don't have the concept of "learning" at all. Conversation ends, context clears, next round starts over. At best they give you retrieval augmentation so you can search past conversation snippets—but that's a world away from "learning."
What Hermes does is introduce a complete knowledge lifecycle at the Agent execution level: acquire → distill → test → crystallize → on-demand call → continuous optimization.
/learn pulls this cycle's entry point to an extremely low threshold: any material, one command.
When agents can accumulate experience,沉淀 methodologies, and grow more skilled with practice—the line between "AI assistant" and "AI colleague" may be blurrier than we imagine.






