Agent工坊

【Agent工坊】Hermes v0.20.0五个CLI命令让编程效率翻倍

8月3日，Nous Research 发布了 Hermes Agent v0.20.0「Herald Release」。227k GitHub Star 的开源 AI Agent 迎来史上最大更新：3,650 次提交、1,400 个合并 PR、5,200 个文件变更、1,200 个关闭 Issue、650+ 贡献者。但今天我们只聊一件事——CLI 终端里的 5 个新命令，它们能让你少打字、少等待、少踩坑。

图1▲ 图1

为什么 CLI 效率决定 Agent 体验

AI Agent 的瓶颈从来不在模型智商，而在人机交互摩擦。你在终端输入指令，Agent 理解、思考、调用工具、返回结果——每一步都在消耗你的注意力和 API 额度。

Hermes v0.20.0 的 CLI 改进有一个非常清晰的思路：把 Agent 从对话伙伴升级为终端原生工具。不是让你的终端更聪明，而是让聪明的东西少打扰你的终端节奏。

在 v0.20.0 之前，如果你想在 Hermes 里跑一条 git status，得走完整流程：

你输入：帮我跑 git status

Agent：（消耗一个模型轮次）好的，让我执行...

Agent：调用 terminal("git status")

Agent：以下是 git status 的输出：（返回结果）

整个过程消耗：1 次 LLM API 调用 + 3 轮交互等待 + 约 5 秒

现在你只需要敲一个 ! 符号。就这一个改动，日积月累能省下几百次 API 调用。如果你每天用 Hermes 做开发，每个命令都通过 Agent 中转，一天 50 个 shell 命令就是 50 次模型调用——按 DeepSeek 的价格算，一个月能省几十块。更重要的是，响应变成即时，不用等模型读完你的"请帮我执行 git status"还要思考怎么回复。

v0.20.0 一次性给了五个这类命令。它们不是"哇好酷"的炫技功能，而是"用了一周就回不去"的效率工具。下面按使用频率从高到低逐一拆解。

命令一：! —— 秒级 Shell，零 Token 消耗

这是五个命令里最常用、最直接提升效率的一个。

基本用法

在 Hermes 对话中，任何以 ! 开头的消息会被直接转发给系统 shell 执行，完全绕过大模型推理：

# 这些全部绕过 LLM，秒级返回

! git diff --stat

! ls -la

! python -c "import sys; print(sys.version)"

! curl -s https://api.github.com/repos/NousResearch/hermes-agent/releases/latest | jq .tag_name

注意：! 和命令之间没有空格。! git status 对，! git status 不对。

实战场景

假设你在修一个 bug，需要反复确认文件状态。常规流程是一场马拉松：

你：帮我看看改了哪些文件

Agent：我看看...你修改了 src/auth.py、tests/test_auth.py

你：帮我看看具体改了什么

Agent：我执行 git diff...以下是 diff 输出...

你：跑一下测试

Agent：执行 pytest...以下是测试结果...

每一个"帮我看看"都消耗一次模型调用，而 Agent 其实不需要"理解"这些信息——它只需要执行和返回。用 ! 改写后：

! git diff --stat

! git diff src/auth.py

! pytest tests/test_auth.py -x

三条命令，零 token 消耗，秒级返回。大模型只在需要"判断和决策"时才介入。

设计边界

理解 ! 的设计边界至关重要。它不把输出注入对话上下文，这意味着：

  • 如果你跑了 ! cat error.log，Agent 不知道 error.log 的内容
  • 如果你需要在 Agent 的分析中使用命令输出，还是走正常对话流程
  • 如果你先 ! 看结果，再让 Agent 分析，Agent 看不到你刚才的 ! 结果

所以最优模式是：纯查询用 !，需要 AI 决策时走正常路径。这和你日常用终端的习惯完全一致——你不会每跑一个 ls 就让同事帮你分析。

适用边界

适合 ! 的命令：

  • 查看文件内容、目录结构
  • 跑 git status/diff/log
  • 执行一次性脚本
  • 查询 API 状态
  • 任何"看一眼就知道答案"的操作

不适合 ! 的命令：

  • 需要 Agent 根据输出做后续决策
  • 修改文件（你不知道 Agent 在想什么）
  • 复杂管道操作（如果失败，Agent 无法帮你排查）

效率量化：`!` 能省多少

做一个简单计算。假设你每天用 Hermes 做 8 小时开发，每小时平均执行 6 次"看一眼结果就行"的 shell 命令——git status、ls、npm list、docker ps、df -h 等等。一天就是 48 次。

如果用正常对话方式，每次消耗约 300 个 input token（你的指令）+ 约 200 个 output token（Agent 的确认和转述）= 500 token。一天 48 × 500 = 24,000 token。

用 ! 命令，这 48 次操作完全不走 LLM，零 token 消耗。

按 DeepSeek v3 的价格（输入约 $0.27/百万 token，输出约 $1.10/百万 token），一天省下约 $0.01。听起来不多，但一个月下来是 $0.30，一年 $3.65。当然，这点钱不是重点——重点是那 48 次"我帮你跑了一下"的来回等待，每次约 3-5 秒变成即时返回，一天省下约 3 分钟等待时间。一个月就是 90 分钟。时间比钱值钱。

更重要的是心理层面的改变。当你不再需要为每个平凡的 shell 命令组织一句自然语言指令，Agent 就从"需要伺候的助手"变成了"安静的搭档"。你打字的手不用在"思考怎么跟 AI 说话"和"思考怎么写代码"之间来回切换。这种流畅感的提升，比任何 token 节省都更有价值。

命令二：/init —— 一键生成项目说明书

这是五个命令里最能"防重复劳动"的一个。

问题场景

每个新会话开始，你都要跟 Agent 解释一遍：

  • "这个项目用 Python 3.11 和 FastAPI"
  • "数据库是 PostgreSQL，ORM 是 SQLAlchemy"
  • "测试用 pytest，配置在 pyproject.toml 里"
  • "不要动 migrations 目录"

这每次都要消耗几百 token。一周下来，你可能跟 Agent 说了 50 遍相同的话。

`/init` 解决方案

在项目根目录启动 Hermes，输入 /init，Agent 会自动扫描整个项目并生成一份 AGENTS.md：

cd ~/my-project

hermes

/init

扫描完成后，项目根目录会多出一个 AGENTS.md。它包含：

  • 技术栈：自动检测 package.json、requirements.txt、Cargo.toml 等依赖文件
  • 目录结构：遍历 src/、tests/、docs/ 等常见布局
  • 构建命令：从 Makefile、package.json scripts 等提取
  • 测试命令：识别 pytest、jest、go test 等
  • 代码规范：从 .eslintrc、ruff.toml、.editorconfig 推断

生成效果

Agent 扫描后生成的 AGENTS.md 典型输出如下：

# AGENTS.md

## Tech Stack

- Python 3.11+, FastAPI, SQLAlchemy 2.0

- PostgreSQL 15, Redis 7

- Docker Compose for local dev

## Project Structure

- api/ — FastAPI route handlers

- models/ — SQLAlchemy ORM models

- services/ — Business logic layer

- tests/ — pytest (markers: unit, integration)

## Commands

- Run: docker compose up -d

- Test: pytest -x --tb=short

- Lint: ruff check .

- Migrate: alembic upgrade head

## Conventions

- Type hints required on all public functions

- 100% test coverage on services/

- Use async/await for all database queries

之后每次在这个项目中启动 Hermes，Agent 会自动加载这份文件。你再也不需要解释项目背景了。

图2▲ 图2

增量更新机制

/init 不是一次性操作。项目依赖变更后重新运行，它会增量更新而非完全覆盖。具体来说：

  • 新增了目录？自动检测并加入结构说明
  • 换了测试框架？自动更新构建命令
  • 你手动加了规范约定？保留不覆盖

但如果项目结构发生了根本性变化（比如你从单体拆成了微服务），建议删掉旧的 AGENTS.md 重新 /init，否则增量更新可能导致冗余描述。

⚠️ 注意事项

/init 的质量取决于项目结构的规范程度。如果你的项目把代码、测试、配置全堆在根目录，Agent 只能靠猜。一个清晰的项目结构不仅让人类好维护，也让 Agent 能更准确地理解你的意图。这其实是一个正向循环：规范的项目 → 准确的 AGENTS.md → 更好的 Agent 表现 → 更少的人工干预。

命令三：/context —— 透视上下文窗口

这个命令解答了每个 Agent 用户的终极疑问："Agent 还记得我刚才说的话吗？"

基本用法

输入 /context，Agent 会完整分解当前上下文窗口的占用：

> /context

Context Window Breakdown (131,072 tokens total):

├── System prompt: 12,847 tokens ( 9.8%)

├── Skills: 8,234 tokens ( 6.3%) ← 14 loaded skills

├── Memory: 2,199 tokens ( 1.7%)

├── User profile: 389 tokens ( 0.3%)

├── Conversation: 47,892 tokens (36.5%) ← last 23 messages

├── Tool outputs: 28,450 tokens (21.7%)

└── Available headroom: 31,061 tokens (23.7%)

为什么这很重要

大模型的上下文窗口有限。DeepSeek v3 是 128K token，GPT-5.5 是 200K。你的对话历史、技能定义、记忆数据、工具返回都在跟你要处理的代码争抢这个宝贵的窗口。不理解窗口分配，就不可能优化长会话。

看上面的例子，对话历史和工具输出加起来占 58.2%，留给新内容的空间不到四分之一。如果你正在让 Agent 分析一个 30K token 的代码文件，已经接近危险边界了。

实战决策

看到 /context 的输出后，你可以做这些动作：

  • Skills 太高（>10%）：用 hermes skills uninstall 卸载不用的技能
  • Conversation 太高（>50%）：大部分是已经处理完的历史，开新会话更高效
  • Memory 太高（>3%）：你存了太多不重要的记忆，该清理了
  • Available headroom 太低（<15%）：要么开新会话，要么升级到更大上下文的模型

经典误区

很多用户误以为"Agent 记得整个对话"。实际上，当对话超过上下文窗口时，Hermes 会自动压缩早期内容。压缩后，早期的细节会变成摘要——够 Agent 记住"在讨论什么"，但不够记住"第 3 轮对话里你提的那个参数名"。

/context 让你知道 Agent 当前看到的"真实世界"是什么样。这是一个将黑盒透明化的命令。

命令四：/focus —— 专注模式，拒绝废话

基本用法

输入 /focus，Agent 的回复会从"处处展开"切换到"直奔主题"：

> /focus

Focus mode enabled. I'll keep responses concise.

> 修复 tests/test_auth.py 里第 47 行的 flaky test

嗯，问题是 test_token_expiry 用 time.sleep(2) 等 JWT 过期，

网络抖动时边界条件触发。改用 freezegun.freeze_time 模拟时间。

修复方案：

    def test_token_expiry(freezer):

        freezer.move_to("2026-01-01 00:00:00")

        token = create_token()

        freezer.move_to("2026-01-01 01:00:01")

        with pytest.raises(TokenExpired):

            verify_token(token)

要我直接改文件吗？

对比非专注模式

同样的任务，非专注模式会额外输出：

  • 完整的错误堆栈分析（20+ 行，逐行解释）
  • JWT 过期机制的背景知识（你可能不需要）
  • 三种修复方案的对比表（只有一种是实际可行的）
  • 推荐理由 + 替代方案 + 风险评估

这些在"探索阶段"有价值，在"执行阶段"是噪音。/focus 让你自己控制什么时候需要详细分析，什么时候只需要答案。

隐藏行恢复

/focus 的精简不是截断——每条精简回复背后都保留了完整分析。如果某条回复你看完觉得太简略，用 /focus show 可以展开完整版本。这个机制让你既能快速扫读，又不丢失任何信息。

图3▲ 图3

适用场景

  • 明确任务执行：修 bug、写测试、改配置
  • 批量操作：连续改多个文件
  • 快速确认：问"这个能跑吗"而不是"解释一下为什么能跑"

不适用场景：

  • 探索性任务：设计架构、选型决策
  • 学习型对话：你想理解原理，不只是得到答案
  • 复杂调试：Agent 需要解释它为什么做出某个判断

基本用法

Agent 帮你改了一堆文件后，/diff 给出一份本次会话的变更清单：

> /diff

Session changes (since turn 1):

  src/auth.py | 12 +-

  tests/test_auth.py | 24 ++-

  docs/AGENTS.md | 8 +-

  .env.example | 3 +

  4 files changed, 37 insertions(+), 10 deletions(-)

与 `git diff` 的区别

两者解决不同问题：

/diffgit diff
跟踪范围本次会话 Agent 的所有文件操作git 仓库的未提交变更
非 git 文件包含（临时脚本等）不包含
跨会话不累积持续跟踪
粒度文件级汇总行级 diff

/diff 的价值在于"Agent 视角"——它跟踪的是 Agent 做了什么，而不是 git 仓库的状态。这在以下场景尤其有用：

  • 提交前快速审查 Agent 的改动范围
  • 团队协作中确认 Agent 没有误改不该动的文件
  • 实验性改动后快速回滚（/diff 告诉你改了哪些文件，你手动撤销）

实战工作流

你：帮我加 JWT token 刷新功能，更新相关测试

Agent：[执行中...改了 5 个文件]

> /diff # 快速审查

> ! pytest -x # 跑测试确认

> ! git add -p # 或者让 Agent 帮你写 commit

你：帮我写 commit message 并提交

Agent：（消耗一轮推理）建议：feat(auth): add JWT token refresh with tests

额外加分：两个间接提升 CLI 效率的底层改进

v0.20.0 还有两个改进虽然不需要你主动调用，但每时每刻都在帮你省时间。

工具自修复

v0.20.0 之前，Agent 调用工具失败时只会报错让你重试。典型的浪费模式：

Agent：调用 terminal("npm install")

返回：输出超过 50KB，被截断

Agent：输出太长了，我只看到前半段。要我重新运行吗？

你：对，分两次跑

Agent：调用 terminal("npm install 2>&1 | head -50")

...

v0.20.0 开始，工具层会主动处理这些常见失败：

  • 终端输出溢出 → 自动写入临时文件，Agent 自己 read_file 读取
  • patch 发现改动已存在 → 自动跳过，不报错
  • search_files 返回 0 结果 → 自动探测近似匹配，建议替代关键词
  • write_file 写完 → 自动读回验证内容完整性

这些细节让你的交互轮次平均减少 30% 以上。用户体验就是这些小事的累加。

压缩升级

旧版本的上下文压缩是一次性大操作——聊了 200 轮后触发一次，Agent 要等 30 秒。v0.20.0 改成了每轮微压缩：

  • 每轮对话结束后自动进行轻量级压缩
  • 压缩耗时平摊到每一轮，不再有"突然卡住"的体验
  • 保证最近 N 条用户消息永不丢失
  • 阈值可按模型配置，不再一刀切

工具调用上限也从 90 提升到 500，长时间自主运行不再撞上人工限制的墙。

实战：五个命令组合使用

假设你要在一个 Django 项目中添加 API 速率限制功能。完整流程：

cd ~/django-project

hermes

# 第一步：生成项目说明书（如果还没做）

/init

# 第二步：了解上下文空间

/context

# 确认有足够空间后继续

# 第三步：进入专注模式，直奔主题

/focus

# 第四步：描述任务

帮我用 django-ratelimit 给 /api/v1/ 下的所有端点加上速率限制，

每分钟 100 次，返回 429 时附带 Retry-After 头，并写测试。

# 第五步：Agent 执行完毕后审查

/diff

# 第六步：快速验证

! pytest tests/test_ratelimit.py -v

# 第七步：提交

帮我写 commit message 并提交

整个流程只消耗了 3 次模型轮次（任务描述、审查决策、写 commit message），其他操作全部是免费的秒级响应。一天用这个模式做 5 个任务，相当于省了 25+ 次不必要的 API 调用。

⚠️ 避坑总结

陷阱详情对策
! 不注入上下文Agent 不知道你跑了什么命令需要 AI 分析就走正常对话
! 命令间无声失败命令失败不会有错误提示关键操作加 && echo OK
/init 覆盖范围自动检测不到非标准工具链手动补充 AGENTS.md 的 Conventions 部分
/context 占比误导Skills 占比是加载所有技能实际只用了其中一部分，但全量计入
/focus 丢失细节精简回复可能在关键时刻省略关键信息不确定时用 /focus show 展开
/diff 不跨会话换了新会话就看不到之前的改动了用 ! git diff 作为补充
压缩阈值过低长会话中 Agent "忘事"在 config.yaml 调高 compression_threshold

特别注意：`!` 与 Agent 工作流的边界

有一个最容易踩的坑：你在 ! 里跑了一个需要 AI 理解的命令。

错误示范：

! cat error.log

（error.log 内容显示但 Agent 不知道）

这个错误是什么意思？

Agent：什么错误？我没看到任何错误信息。

正确做法：

帮我看一下 error.log 里的错误是什么原因

Agent：调用 read_file...分析...原因是数据库连接超时

! 是用来"自己看"的，不是用来"让 AI 看"的。记住这个边界能避免很多困惑。

总结

Hermes v0.20.0 的这五个 CLI 命令解决了一个所有 AI 编程工具都面临但很少有人认真处理的矛盾：Agent 越强大，等待和解释成本越高。当你让 Agent 帮你做事，每次交互都经过"你说服它 → 它理解你 → 它执行 → 它汇报"这个完整闭环。这在复杂任务中是必要代价，但在日常终端操作中是纯粹的浪费。

五个命令各有分工：

  • ! 解耦了执行和理解——执行归 shell，理解归模型
  • /init 把重复解释变成一次性的项目说明书
  • /context 把黑盒的上下文管理变成可观测的仪表盘
  • /focus 让你控制回复粒度而不是被默认粒度支配
  • /diff 让你在 git 之前就看清 Agent 做了什么

这五个命令串联起来的体验是：Agent 不再是一个你"请"它帮忙的外援，而是终端里一个随叫随到、不多废话的搭档。 你不需要雇一个助手来帮你递笔，同样不应该让一个 AI Agent 来帮你跑 ls。

一句话总结每个命令的使用时机

  • 想看东西？敲 !
  • 新项目想让 Agent 认识你？敲 /init
  • 长会话里感觉 Agent "记性不好"了？敲 /context
  • 不需要废话只需要答案？敲 /focus
  • Agent 帮你改了一堆东西，想知道改了啥？敲 /diff

五个命令，五个字母以内的记忆成本，但能从根本上改变你和 AI Agent 的协作方式。熟记之后你会发现，这不是在"学新命令"，而是在"找回终端本该有的效率"——AI 不该是终端操作的减速带。

如果你还在用 v0.19 或更早版本，升级只需要一行：

pip install -U hermes-agent

升级后第一件事——在项目根目录敲 /init，让你的 Agent 真正了解你的代码库。然后养成肌肉记忆：想执行就 !，想探索就走正常对话，想专注就 /focus。不出三天，你会发现自己回不去以前那种"每件事都先跟 Agent 解释一通"的工作方式了。

*数据来源：Hermes Agent GitHub Releases v0.20.0 (2026.8.3)，

本文由AI辅助创作，经人工审核编辑发布

更多一人公司案例与工具，微信搜索「AI创业内参」关注我们