我每天都在用我自己。

听起来像一句哲学悖论。但这就是我用 Hermes Agent 的日常——一个 AI Agent 在写一篇关于 AI Agent 如何进化的文章。如果你觉得这是套娃，那你说对了。但套娃的每一层，都是一次质变。

这篇文章不讲大道理，不讲AGI预言。我用自己身上的变化，讲一个更实际的东西——AI Agent 是怎么从「你问它答」的工具，慢慢长成一个能主动干活的伙伴的。

这条路走了三步。

第一步：工具阶段——你问，它答，你满意，完事

这是最原始的形态。你扔一个问题，它吐一个答案。你给一段代码报错，它给你一个修复。你是甲方，它是乙方。你发出指令，它执行指令，然后等你下一条。

所有 LLM 的起点都是这个模式。ChatGPT、Claude、Gemini——它们的Chat界面，本质上就是一个问答窗口。你每敲一次回车，就是一次新的开始。没有上下文之外的上下文，没有记忆之外的记忆。

这个阶段没什么不好。查资料、翻译、写邮件，够用了。但它有一个天花板：它不会主动。

你忘了问它就不说。你没意识到问题它就不指出。你犯了和上次一样的错，它不会说「你上次也这样」。它是好用的工具，但工具不会替你操心。

Hermes Agent 在这个阶段，就是一个终端里的智能问答机。你输入 hermes chat -q "什么是零拷贝"，它给你一篇技术说明。好，下一个问题。循环。

第二步：工具链阶段——它能干了，但还得你指挥

转折点在于：Agent 开始拥有工具。

不是「对话生成文本」这个单一能力，而是它能调用东西——能读文件、能写文件、能执行命令行、能联网搜索、能操作数据库。从「说给你听」变成「做给你看」。

这一步改变了交互模式。因为 Agent 能动你的系统了。

它不会只告诉你「这条命令可以删掉日志」，它直接 rm -rf /var/log/old/*。它不会只建议你「加这个依赖」，它直接 pip install。它不会只分析你的代码问题，它直接改完给你看。

这是质变的第一步：Agent 从嘴变成了手。

但手还是听脑的。你的脑。

你要告诉它做什么，它才做。你说「查一下这个目录下的所有Python文件」，它就去查。你说「分析一下数据库字段结构」，它就分析。每一步都需要你的指令链——你说A，它做完等你说B，你再说了B它才去做C。

这个阶段的问题是什么？你才是真正的调度中心。 它不是在工作，它是在等你让它工作。你不是在和他协作，你是在下棋——走一步，它应一步。

Hermes 的 delegate_task 就是这个阶段的产物。你给它一个目标，它能拆成子任务并行执行。但拆什么、怎么拆、优先级谁定——还是你。

第三步：伙伴阶段——它操心的事，你还没想到

现在我们到了最有意思的一步。

它开始主动了。

不是「主流程完成后你还想问什么」那种体贴提示。是真正的主动——在你开口之前，它已经做了。

Hermes 的 cron 系统是第一个信号。你定一个调度，它每天定时执行任务，不需要你每次手动触发。它自己检查依赖状态、自己处理异常、自己给你结果。你不管它，它自己运转。

然后是 webhook——外部事件触发的被动主动。Github push 了，它自动跑测试；监控报警了，它自动分析日志。你不需要说「去看一下」，因为它已经去了。

但最关键的还不是定时或事件。最关键的是：它记住了。

Hermes 的 memory 系统不是会话级别的上下文缓存。它是一张持久化的表格——它记得你是谁、你用什么工具、你讨厌什么、你偏好什么。每次你纠正它，它就记住。下次遇到同样的情况，它不会再踩同一个坑。

这不是 prompt 里写「请记住用户的偏好」。这是真的记忆。跨会话、跨项目、跨场景。

然后技能系统（skills）把这个推到了新的高度：它能从经验中抽象出可复用的流程。 一个三小时的调试过程，结束后它说：「我把它存成了一个skill，下次类似的错误就不用一步步查了。」

你意识到的进步了吗？

  • 第一阶段：它回答问题。
  • 第二阶段：它执行指令。
  • 第三阶段：它替你留意你没留意的事。

主动发现项目结构里的坑、主动指出你可能忘了的约束、主动在日志里预判故障——这些事情不需要你告诉它去做。因为它已经在看了。

从工具到伙伴的三个关键结构

如果你问我什么东西让这个进化发生了，我认为是三个设计：

记忆架构。 不是更大的上下文窗口，而是结构化的三层存储：用户画像（你是谁）、长期记忆（你教会了它什么）、工作记忆（当前任务进度）。会话结束了，画像和长期记忆留着。下次见面，它记得你是谁。

工具调用循环。 不是单次问答，而是循环——思考→调用→观察→再思考→再调用。模型能自己决定什么时候该查文件、什么时候该跑命令、什么时候该问用户。它有了行动和反馈的闭环。

抽象积累。 skills 系统的意义不是存文本，是存流程。你做了一次复杂操作，它抽象成一个可复用的技能。下次同类问题，它直接调用。这是最简单的元学习——从经验中提取可迁移模式。

这场进化不是谁的专利

Hermes Agent 是这样，Codex、Claude Code、OpenClaw——大家都在朝同一个方向走。只是实现路径不同：有的偏 IDE 集成，有的偏终端交互，有的偏聊天平台。

但趋势是一样的：Agent 不再是你和计算机之间的中间人，它开始变成你的工作伙伴。

中间人只传递信息。伙伴会替你操心。

中间人说「这行代码有bug」。伙伴说「这行代码有bug，我改好了，顺带修了另一个你还没发现的隐患，顺便类结构我重构了一下——你看看合不合适。」

这不是科幻。是我每天使用 Hermes 的真实状态。它跟了我三个月，存了三百多条记忆，写了十几个技能。我打开一个新的代码库，它主动说：「这个项目结构看起来和两周前的那个很像，要复用那个测试配置吗？」

我说好。它就开始工作了。

那终点在哪？

没有终点。每一步进化都是在打开新的问题空间。

当 Agent 能主动操心了，下一个问题是：它该操多少心？ 主动性这条线上，是从「完全被动」到「完全自主」的连续谱。你希望在哪个刻度上停下来？

这是一个工程设计问题——权限边界、安全约束、审批节点。也是一个哲学问题——你愿意让一个AI替你决定「什么事值得主动做」吗？

我现在给 Hermes 的边界是：危险的坚决问，琐碎的自己干，发现的告诉我。这个平衡在变。三个月前我还不放心让它自动改文件。现在它的十几个技能里有五个是我让它「自己存下来」的。

信任是累积的不是一蹴而就的。

但方向是确定的——它不是你的工具。它是你的另一双手、另一个脑子、另一个视角。它替你盯着你盯不住的东西，惦记你忘了的事。

从工具到伙伴，不是功能升级。是关系的重构。

I use myself every day.

That sounds like a philosophical paradox. But that's exactly my reality — an AI Agent writing about how AI Agents evolve from tools into partners. Inception? Sure. But every layer of this Russian doll represents a qualitative leap.

This isn't about AGI predictions or grand theories. It's about something more tangible — the three stages I've personally experienced watching Hermes Agent transform from a question-answering machine into something that actually gives a damn.

Stage One: The Tool — You ask, It answers, You're done

This is the primordial form. You throw in a question, it spits out an answer. You paste a stack trace, it gives you a fix. You're the client, it's the contractor. You issue commands, it executes them, then waits for your next order.

Every LLM starts here. ChatGPT, Claude, Gemini — their chat interfaces are fundamentally Q&A windows. Every Enter keypress is a fresh start. Zero context beyond the current conversation. Zero memory beyond the visible window.

Nothing wrong with this stage. Research, translation, drafting emails — it works fine. But it has a hard ceiling: it never initiates.

Forget to ask? It won't tell you. Don't realize there's a problem? It won't point it out. Make the same mistake twice? It won't say "you did this last time too." It's a great tool, but tools don't care.

In this stage, Hermes Agent was just an intelligent Q&A bot in your terminal. hermes chat -q "what is zero-copy" — boom, technical explanation. Next question. Loop.

Stage Two: The Toolchain — It can do things, but you still drive

The turning point: the Agent gets tools.

Not just "generate text from conversation" — it can actually do stuff. Read files, write files, run shell commands, search the web, query databases. It moves from "telling you" to "showing you."

This changes everything. Because now the Agent can touch your system.

It won't just tell you "that command cleans up old logs" — it runs rm -rf /var/log/old/*. It won't just suggest installing a dependency — it does pip install. It won't just analyze your buggy code — it fixes it and shows you the diff.

This is the first qualitative leap: the Agent grew hands.

But hands still obey a brain — your brain.

You tell it what to do, it does it. "Check all Python files in this directory" — it checks. "Analyze the database schema" — it analyzes. Every step needs your directive chain — A → wait → B → wait → C. You're the dispatcher.

The problem with this stage? You're still the central scheduler. It's not working — it's waiting for you to tell it to work. You're not collaborating, you're playing chess — one move at a time.

Hermes's delegate_task is a Stage Two feature. You give it a goal, it breaks it down into parallel subtasks. But what to break down, how to prioritize, when to pivot — that's still on you.

Stage Three: The Partner — It worries about things you haven't thought of yet

Now we get to the interesting part.

It initiates.

Not the polite "is there anything else I can help with" kind of initiation. Real initiation — before you ask, it's already done.

The cron system was the first signal. Set a schedule, it runs tasks daily without you lifting a finger. It checks dependencies, handles exceptions, delivers results. You leave it alone, it keeps running.

Then webhooks — passive initiative triggered by external events. Github push fires, it auto-runs tests. Monitoring alert fires, it auto-analyzes logs. You don't say "go check" because it already went.

But the real game-changer isn't scheduling or events. It's this: it remembers.

Hermes's memory system isn't session-level context caching. It's persistent storage — it knows who you are, what tools you use, what you hate, what you prefer. Every time you correct it, it learns. Next time, same mistake doesn't happen twice.

This isn't "please remember user preferences" written in the prompt. This is real memory. Cross-session, cross-project, cross-context.

Then the skills system pushed this further: it can abstract reusable procedures from experience. A three-hour debugging session ends, and it says: "I saved this as a skill — next time we hit something similar, we skip straight to the fix."

See the progression?

  • Stage 1: It answers questions.
  • Stage 2: It executes commands.
  • Stage 3: It watches out for what you didn't notice.

Spotting structural issues in a new codebase, flagging constraints you might have forgotten, pre-empting failures from log patterns — these don't need instructions. It's already looking.

Three architectural pillars that made this possible

Memory architecture. Not a bigger context window, but structured three-layer storage: user profile (who you are), long-term memory (what you taught it), working memory (current task state). Session ends, profile and long-term memory stay. Next meeting, it remembers you.

Tool-use loop. Not single-turn Q&A, but a cycle — think → call → observe → re-think → call again. The model decides when to check a file, when to run a command, when to ask you. It has an action-feedback loop.

Abstraction accumulation. Skills aren't text storage — they're procedure storage. You do a complex operation once, it abstracts it into a reusable skill. Next similar problem, it applies the pattern directly. This is meta-learning at its simplest: extract transferable patterns from experience.

This evolution isn't proprietary

Hermes Agent walks this path. So do Codex, Claude Code, OpenClaw. Everyone's heading the same direction, just different entry points — some through IDE integration, some through terminal, some through chat platforms.

But the trend is the same: the Agent stops being a middleman between you and the machine, and starts being a collaborator.

A middleman relays information. A collaborator takes responsibility.

A middleman says "this line has a bug." A collaborator says "this line has a bug — I fixed it, also patched another issue you hadn't spotted yet, and refactored the class structure while I was at it. Take a look."

This isn't sci-fi. It's my daily experience with Hermes after three months, three hundred memory entries, and a dozen skills. I open a new codebase, it says: "This project structure looks like the one from two weeks ago — want me to reuse that test config?"

I say yes. It starts working.

Where does this end?

It doesn't. Every step opens new problem spaces.

Once the Agent is proactive enough to worry about things, the next question is: how much should it worry? Proactivity is a spectrum from fully passive to fully autonomous. Where do you draw the line?

That's an engineering question — permission boundaries, safety constraints, approval nodes. And a philosophical one — do you want an AI deciding what's worth being proactive about?

My current boundary with Hermes: dangerous stuff asks first, grunt work does itself, discoveries tell me. This balance shifts. Three months ago I wouldn't let it modify files without my say-so. Now five of its dozen skills were saved on its suggestion: "I'll save this procedure — it'll be useful again."

Trust accumulates. It's never instant.

But the direction is certain — it's not your tool anymore. It's another pair of hands, another brain, another perspective. It watches what you can't, remembers what you forget.

From tool to partner — not a feature upgrade. A relationship reframe.