C CONVEE 搜索

Agent 架构文档 · Markdown

Agent 入门 primer：用 Claude Code / Hermes / OpenClaw 三家对照学原理

目标读者：第一次认真学 agent 原理的工程师 / 想横向选型的架构师入门段。 阅读时间：30 分钟。读完应该能：①讲清"agent 到底是个什么东西"；②说出三家的定位差 异；③知道想深挖某个点时翻哪份长文哪一节。 配套的三份深度文档（每份 1500+ 行，架构师向）： claude code agent architecture.md hermes a

来源文件：agent-primer-3way.md · 阅读时间 13 分钟

目标读者：第一次认真学 agent 原理的工程师 / 想横向选型的架构师入门段。

阅读时间：30 分钟。读完应该能：①讲清"agent 到底是个什么东西"；②说出三家的定位差 异；③知道想深挖某个点时翻哪份长文哪一节。

配套的三份深度文档（每份 1500+ 行，架构师向）：

  • claude-code-agent-architecture.md
  • hermes-agent-architecture.md
  • openclaw-agent-architecture.md

本 primer 是它们的"上层入口"，不替代它们。

#§0 5 分钟前置：在读架构之前先懂这几件事

#0.1 你需要先知道这 6 个词

词 30 字解释 一行示例
LLM 一个吃文本吐文本的概率模型，无状态、不会主动做事 GPT-4 / Claude Sonnet 4.6 / Hermes 4 70B
context window LLM 单次推理能看到的"短期记忆"上限（按 token 算） 200K tokens ≈ 一本中篇小说
system prompt 拼在用户消息前面、告诉模型"你是谁、规则是什么"的一段文本 "You are a careful coding assistant…"
tool call / function calling 模型不直接执行动作，而是输出一段"我想调用 X 工具、参数 Y"的结构化文本，由外部 runtime 真正执行 模型说 read_file("a.md") → runtime 读文件 → 把内容塞回 context
ReAct loop 模型 → 想 → 调工具 → 看结果 → 再想 → … 直到觉得能回答了，停下来出答案 几乎所有 agent 的主循环都是这个
MCP (Model Context Protocol) Anthropic 推的一个"agent 怎么接外部工具"的标准协议，让一份 MCP server 能被多家 agent 用 你写一个 Jira MCP，Claude Code 和 Hermes 都能用

读懂这 6 个词，下文 90% 内容能跟上。

#0.2 一段 hello-world 对话的剖面

不管哪家 agent，一次"用户说话 → agent 回答"内部都长这样：

用户："帮我读一下 README.md，告诉我这个项目是干嘛的"
         │
         ▼
[1] runtime 把 [system prompt + 历史消息 + 这条新消息 + 工具 schema] 一起送给 LLM
         │
         ▼
[2] LLM 输出：「我需要先读文件」+ tool_call: read_file("README.md")
         │
         ▼
[3] runtime 看到 tool_call，真的去读 README.md，得到内容
         │
         ▼
[4] runtime 把 [...上面那一坨 + LLM 的 tool_call + 读文件的结果] 再送给 LLM
         │
         ▼
[5] LLM 这次看到了文件内容，决定不用再调工具了，直接输出文本回答
         │
         ▼
[6] runtime 把回答展示给用户

关键认知：

  • LLM 自己什么动作都没做，所有"读文件 / 跑命令 / 发消息"都是 runtime 在做
  • LLM 只负责"想 + 决定要调什么工具"
  • agent 这个词，指的是 LLM + 这一整套 runtime，不是单指模型

#0.3 Agent = Model + Harness

业界（Anthropic / Cursor / Cline 等）现在普遍认同一个等式：

Agent  =  Model (LLM)  +  Harness (模型之上的外壳)

Model 是大脑，Harness 是"让大脑真正能干活的躯壳"。三份长文都用同一个 4 层结构拆 Harness：

层 干什么 举例
① 指令层 告诉 agent"你是谁、规则是什么、有哪些工具能调" system prompt, CLAUDE.md, SKILL.md
② 能力层 给 agent 真正能用的工具 Read/Edit/Bash 内置工具、MCP、社区 skill
③ 基础设施 让工具能安全跑、状态能持久化、能跨设备 权限系统、沙箱、SQLite、worktree
④ 可观测 能看到 agent 干了什么、花了多少 OTel hooks、事件总线、session 日志

同一个模型放进不同的 Harness，能力差距会非常大——这就是为什么 Cursor / Codex / Aider 用同一批 Anthropic 模型，效果完全不一样。本 primer 后面 7 问，本质上就是 7 个不同的 Harness 设计选择题。

#§1 三家是干嘛的（30 秒消歧）

维度 Claude Code Hermes OpenClaw
出品方 Anthropic 官方 Nous Research（开源社区） Peter Steinberger（独立开发者）+ 社区
定位 改你代码的 agentic coding tool 开源模型 + 自进化 runtime 流水线 长跑在你电脑上的个人 24×7 助手
主战场 终端 / IDE / 代码仓库 模型研究者 / 自建 agent 平台 IM（WhatsApp/iMessage/Telegram…）+ macOS/iOS
主要用户 开发者 LLM 研究者 + 想自建开源 agent 的工程师 想要私人助理的个人用户
主要语言 TypeScript（CLI/harness） Python TypeScript（Gateway + extensions）
模型策略 只支持 Anthropic 自家模型（Sonnet/Opus/Haiku） 主推 Hermes 4，但接 30 家 provider 模型无关，主用 OpenRouter
开源 CLI 闭源、SDK 部分开源 全栈开源（模型权重 + 协议 + runtime） MIT 全开源
一句话特色 permission 系统 + hook 生态最强 把 function calling 训进模型权重 把"手机和 IM 当感官"做成 first-class

记住一件事：这三家不是直接竞品，它们解决的是三个不同问题。把它们对照看是为了理解"同一个 agent 概念，被三种不同场景压力塑造出三种不同形态"。

#§2 Agent 的身份是怎么定的？

#通用原理

任何 agent 的"身份"都是这几样东西拼出来的：

身份 = 模型选择 + 系统提示 + 工具清单 + 个性/规则文件 + 权限边界

最关键的观察：现代 agent 的"一个 agent" ≠ 一个进程，而是 ≠ 一段服务代码，而是 = 一份 markdown 配置 + 一个通用执行引擎。改 markdown 就能造一个新 agent。

#三家怎么做

维度 Claude Code Hermes OpenClaw
身份的"主键" frontmatter 里的 name + 一份 markdown 文件 personality 文件 + 模型权重 + SKILL.md 集合 workspace 目录 + IDENTITY.md + SOUL.md
在哪儿存 ~/.claude/agents/*.md 或 <repo>/.claude/agents/*.md ~/.hermes/personalities/、~/.hermes/skills/ 一个 workspace 目录（含 .md 文件）
多 agent 共存的方式 subagent（独立 context 的子执行体） 多 profile（每个 profile 一个完整目录） 一台机器一个 daemon，但可挂多个 SOUL
怎么发布给别人 拷贝 .md 文件 Hermes Skills Hub ClawHub（SOUL/SKILL 商店）
一句话 takeaway 配置即身份，subagent 是隔离的"小号" 身份分模型层 + 协议层 + runtime 层三层 workspace 就是 agent 的私人办公室

共同点：三家都把身份做成文件而非数据库记录——人类可读、可 diff、可 git、可分享。这是 2026 年的事实标准。

#想深挖

  • Claude Code §1（配置即身份的无中心 agent）
  • Hermes §1（Model + SKILL.md + 系统提示三件套）
  • OpenClaw §1（Workspace + IDENTITY + SOUL）

#§3 Agent 是怎么被唤起的？

#通用原理

agent 的"入口"分两种：

  • 同步入口：用户主动触发（敲命令、点按钮、IDE 里 @），等结果
  • 异步入口：定时器 / webhook / 别的进程消息触发，agent 自己活起来

入口多≠agent 多。好的设计是 一个 agent 核心 + N 个外壳（入口），避免每个入口各搞一份循环。

#三家怎么做

维度 Claude Code Hermes OpenClaw
入口形态 CLI / IDE 插件 / Web / Desktop / Remote / Direct Connect CLI / TUI / 20 个聊天平台 / cron / ACP / MCP / Kanban worker 21 个 IM channel / macOS 菜单栏 / iOS&Android node / cron / Canvas
唯一内核 共用一份 agent loop AIAgent.run_conversation() 一份内核服务所有外壳 Gateway daemon (127.0.0.1:18789) 单进程吃下所有 IO
并发模型 主 session 串行；可 spawn subagent；agent team experimental 单进程内串行；Kanban 跨进程多 worker 协作 session lane 严格串行；spawn sub-agent 走独立 session
异步触发 ScheduleCron / 后台任务 cron + no_agent 模式 + Multi-agent Kanban Cron skill（agent 自己的闹钟）+ IM 推送
一句话 takeaway 同一个 binary 走 N 个 surface 单进程多外壳 + Kanban 跨进程任务板 Gateway 守着所有 channel 路由到 agent

共同点：都遵循"单核心多外壳"——三家都明确反对"每个入口写一份 agent loop"。

#想深挖

  • Claude Code §2
  • Hermes §2（特别 §2.2 触发入口多样性）
  • OpenClaw §2

#§4 Agent 怎么思考？（ReAct 主循环）

#通用原理：30 行伪代码看完

def run_agent(user_input, max_iterations=50):
    messages = [system_prompt, user_input]

    for i in range(max_iterations):
        # 1. 把全部上下文 + 工具 schema 送给 LLM
        response = llm.chat(
            messages=messages,
            tools=available_tools,
        )

        # 2. LLM 输出可能是「直接回答」或「想调工具」
        if response.tool_calls:
            # 3. 真正去执行工具（这一步 LLM 没参与）
            tool_results = []
            for call in response.tool_calls:
                result = execute_tool(call.name, call.arguments)
                tool_results.append(result)

            # 4. 把 LLM 的 tool_call 和执行结果追加到对话，进入下一轮
            messages.append(response)
            messages.extend(tool_results)
            continue
        else:
            # 5. 没有 tool_call 了，说明 LLM 决定收尾，把答案返回用户
            return response.text

    raise IterationLimitExceeded()

就这 5 步。所有所谓 "agent 架构" 都是在这个骨架上加东西：

  • 怎么压缩 messages（长了会爆 context window）
  • 怎么并行执行多个 tool_call
  • 怎么让模型先"想一会儿再调"（reasoning / <think>）
  • 怎么跨多轮锁定目标，别跑偏

#三家怎么做

维度 Claude Code Hermes OpenClaw
主循环位置 内部 agent loop run_agent.py: run_conversation() ~16k 行 session 内的 Run，串行 lane 锁
最大迭代 由 context budget 控制 max_iterations=90 + iteration_budget 由 Run 控制，没有硬上限
让模型"先想再做" plan mode（限制工具集 + 强制先汇报）+ opus 跑 plan / sonnet 跑 execute <think> 标签训进权重，模型自己决定是否展开 CoT 靠 prompt 引导，没专门机制
子任务怎么开 spawn subagent（独立 context） spawn sub-conversation / Kanban worker（跨进程） spawn sub-agent（独立 session，默认 Docker sandbox）
跨 turn 锁目标 plan mode 状态机 /goal Ralph loop（judge 模型评估完成度，循环到达成） 无专门机制
一句话 takeaway 主循环朴素，靠 plan mode + subagent 拼复杂度 思考方式部分下沉到模型权重 思考朴素，靠 lane 锁保证一致性

一个关键洞察：Hermes 的做法（把"什么时候 think"训进权重）和 Claude Code 的做法（plan mode 在 runtime 强制）是两条不同哲学路径：

  • Hermes：能下沉到模型权重的，就别做在框架里
  • Claude Code：模型不一定可靠，runtime 该兜底就兜底

OpenClaw 在思考层最薄，因为它的核心场景不是"打 SWE-bench"，是"24×7 不卡壳"。

#想深挖

  • Claude Code §3（主循环 / 子代理 / 并发团队）
  • Hermes §3（ReAct + <think> + /goal Ralph loop）
  • OpenClaw §3（单 Run 串行 ReAct + sub-agent 委派）

#§5 Agent 怎么用工具？（function calling 协议）

#通用原理

工具调用的核心问题是：LLM 输出的是文本，怎么让它精确表达"我要调用 X 函数、参数是 Y"？

业界两条路：

  1. 私有 API 协议（OpenAI tools / Anthropic tool_use）：模型厂在 API 层定义结构化字段，开源不可用
  2. 公开标签协议（Hermes <tool_call>{json}</tool_call> / ChatML）：用特殊 token 包 JSON，开源可复现

无论哪种，runtime 都得做这几件事：

  • 把工具 schema 塞进 system prompt（让模型知道有哪些工具能调）
  • 解析模型输出里的 tool_call 结构
  • 真正执行（同步 / 并发 / 沙箱）
  • 把结果格式化塞回 context

工具来源也有三个层次：

  • 内置工具（read/write/bash 这种通用必需品）
  • MCP servers（标准化的外部工具协议，跨 agent 通用）
  • 社区扩展（skill / plugin / soul，按 agent 自己的格式）

#三家怎么做

维度 Claude Code Hermes OpenClaw
工具调用协议 Anthropic tool_use（API 内置） Hermes <tool_call>{json}</tool_call>（开源标签） Anthropic / OpenAI 协议透传
协议在哪儿翻译 API 层（Anthropic 后端） 模型推理引擎层（vLLM --tool-call-parser hermes） 走 OpenRouter，由 provider 决定
内置工具数量 ~15 个核心（Read/Edit/Bash/Glob/Grep/Agent/Skill 等） 47+ 个 ~25 个
并发执行 主循环并发 tool_calls ThreadPoolExecutor(max=8) + 路径粒度锁 单 session 内串行
MCP 支持 一等公民（http/sse/stdio） stdio + SSE + OAuth stdio 内置，SSE/HTTP via plugin
社区工具机制 skill（描述常驻 / body 用时进） SKILL.md：25 个内置 + 18 个 optional + Skills Hub Skills（5400+ 社区 / 53 内置）+ ClawHub
沙箱选项 worktree 隔离 / protected paths 8 种 terminal backend（local/docker/ssh/daytona/modal/…） Docker sandbox 默认给 sub-agent
一句话 takeaway 协议在 API 层，工具用按需加载省 token 协议下沉到模型权重，runtime 只做 dispatch 工具丰富但运行在用户机器上，靠 Docker 隔离

关键差异：

  • Claude Code 押注"按需加载"——MCP schema 默认 deferred，靠 ToolSearch 用时拉，省 context token
  • Hermes 押注"训进权重"——模型自己懂 <tool_call> 语法，runtime 极薄
  • OpenClaw 押注"社区生态"——5400+ skill 是它的护城河

#想深挖

  • Claude Code §4（工具系统形态）
  • Hermes §4（FC 协议 + ThreadPoolExecutor）
  • OpenClaw §4（Skills / Bundled Tools / MCP / Plugins）

#§6 Agent 怎么记长期记忆？

#通用原理：先理解为什么这是个问题

context window 是 短期记忆——一次推理装得下的对话量。但有两个根本问题：

  1. 会满：200K tokens 也总有装不下的时候。塞太多 token 还会让模型变笨（"context rot"）
  2. 跨 session 没了：你下次再跟 agent 聊，它不记得上次说过什么——除非有外部存储

业界解决方案分两派：

方案 怎么做 优缺点
向量数据库 RAG 把历史对话 embed 进向量库，用时检索 top-k 塞回 context 能装无限多 / 但检索质量飘，调试黑盒
Markdown 文件 + 全文检索 把记忆写成 .md 文件，用 grep/FTS 检索 人类可读、可 diff / 但要 agent 自己决定写什么

2026 年的趋势是后者——三家都选了文件路径，且都让 agent 自己读写 MEMORY.md。

#三家怎么做

维度 Claude Code Hermes OpenClaw
长期记忆形态 五层（System / CLAUDE.md / Auto MEMORY.md / skill / subagent memory） MEMORY.md + SKILL.md + SQLite FTS5 + 8 家 plugin MEMORY.md + memory/YYYY-MM-DD.md 日记 + session.jsonl
跨 session 持久化 按 project 切目录的 ~/.claude/projects/<x>/memory/ + session JSONL --resume SQLite + FTS5 + Checkpoints v2 + session lineage 全是 markdown 文件，session 走 jsonl
检索机制 grep + 自动按 path 关联 FTS5 全文 + Honcho 用户画像 文件读取 + Active Memory 子代理预查
长对话怎么不爆 auto-compact 三段式（先 Session Memory → Snip → forked agent 总结） ContextCompressor v2（token-budget tail + 工具输出剪枝 + iterative summary） session:compact:before/after 包住模型驱动的 compact；/new /reset 触发 session-memory hook 抢救；session.idle / session.maxAge 参数化兜底（无固定时间窗）
Agent 自己写记忆吗 有 auto memory 机制 自己写 MEMORY.md / SKILL.md，自进化闭环 自己写 MEMORY.md + 日记
一句话 takeaway 五层架构 + 自动压缩 文件 + SQLite + agent 自己造 skill 喂下一代模型 三层 markdown + Active Memory 子代理预查

三家都把 markdown 文件 + 关系/全文检索作为长期记忆主线，向量数据库被降级为可选（OpenClaw 内置 memory_recall 走 lancedb，但只是 markdown 三层之外的补充；Hermes 走 SQLite FTS5 而非 vector；Claude Code 完全不做 vector）。这是个值得记住的行业拐点——2024 年大家还都在卷 RAG。

#想深挖

  • Claude Code §5（五层记忆与上下文压缩）
  • Hermes §5（Checkpoints v2 + ContextCompressor v2）
  • OpenClaw §5（MEMORY.md + 日记 + Active Memory）

#§7 Agent 怎么输出 / 多端？

#通用原理

agent 的"出口"有三个维度的复杂度：

  1. 流式 vs 整段：流式让用户感觉响应快，但 hook 拦截 / 改写更复杂
  2. 多平台：CLI 文本 / IDE 富文本 / IM 图文 / 语音 / 文档附件——同一份输出要适配不同形态
  3. 可中断 / 可改写：用户能不能中途打断？hook 能不能改 agent 的输出？

#三家怎么做

维度 Claude Code Hermes OpenClaw
主要输出形态 终端 / IDE 富文本 / Web CLI / TUI / 20 平台 chat / 文档附件 IM 消息 / Canvas / 语音（Talk）/ macOS 通知
多平台机制 多 surface 运行时（CLI / IDE Bridge / Web / Remote / Direct Connect） 20 个 gateway adapter + 自动恢复 + [[as_document]] skill 媒体路由 21 个 channel adapter + Canvas（同端口 capability 路径）
输出改写 hook UserPromptSubmit / SessionStart / 27 事件 24+ plugin lifecycle hook，含 transform_llm_output message hook 链 + PreToolUse/PostToolUse
中断机制 ESC 中断 / Plan mode 强制审核 用户 interrupt signal session lane 锁 + 消息排队
i18n 取系统语言 16 个 locale（zh/zh-hant/ja/de/…）[hermes §6.5] 跟 channel/节点原生语言（待核实，OpenClaw 主文档未单列 i18n 章节）
一句话 takeaway 多 surface 共享一份内核 单进程多 gateway，每个 gateway 一个适配层 Gateway 是事件总线，channel 只管协议适配

#想深挖

  • Claude Code §6（输出回路 / UI / Hook 改写）
  • Hermes §6（单进程多 gateway，20 平台）
  • OpenClaw §6（Channels / Nodes / Canvas / WebSocket 事件总线）

#§8 Agent 怎么换模型？

#通用原理

"换模型"听起来简单，实际涉及四个边界：

  • 协议差异：OpenAI tools / Anthropic tool_use / Hermes <tool_call> 互不兼容
  • 能力差异：有的模型支持流式、有的不支持；有的支持长 context
  • 计费差异：每家定价不同，混用需要统一记账
  • 路由策略：什么任务用 opus、什么任务用 sonnet，由谁决定

#三家怎么做

维度 Claude Code Hermes OpenClaw
支持的模型范围 仅 Anthropic（Sonnet / Opus / Haiku） 30 家 provider（Anthropic / OpenAI / Hermes / OpenRouter / 本地 vLLM…） 任意 OpenAI 兼容（主要走 OpenRouter / iblai-router）
协议适配层 无（自家协议） ProviderProfile ABC + 30 个实现（v0.13 全 plugin 化） OpenRouter 透传
模型路由策略 opusplan 别名（plan 用 opus、execute 用 sonnet） + Auto mode classifier（黑盒） 用户配置 + plugin 决定 用户在 openclaw.json 配
计费可见 --max-budget-usd 总闸，无 per-task 看板 用户自己接入 plugin/observability Run-level tokens 写 transcript，无聚合
一句话 takeaway 锁死自家模型换效率最高 provider 抽象成 plugin，新增 0 改动 core 走中转路由，把模型选择留给用户

#想深挖

  • Claude Code §7（模型路由与 effort 调度）
  • Hermes §7（ProviderProfile ABC + 30 家）
  • OpenClaw §7（模型无关层与 OpenRouter / iblai-router）

#§9 三家的"独门绝活"一句话

这一节是给你 review 完所有 7 问之后回头记忆用的：

  • Claude Code：5 档 permission mode（外部可配；另有 1 档内部 auto，受 feature flag 门控）+ 7 步权限决策 + 27 个 hook 事件 × 4 种 handler，安全 / 拦截 / 可控这块全行业最厚
  • Hermes：把 function calling 和 <think> reasoning 训进模型权重，runtime 反而是最薄的一家
  • OpenClaw：把"IM 当输入设备、电脑当输出设备" first-class 化，21 个 channel + Nodes + Canvas + Talk 语音通道

如果你做选型，记住一个简化判断：

  • 你的 agent 主要服务程序员改代码 → Claude Code
  • 你想自建开源 agent 平台或研究 function calling 数据集 → Hermes
  • 你想做个人助手 / 不在终端而是在 IM 里聊 → OpenClaw

#§10 跳转索引：想深挖哪段，翻哪份长文

你想懂 Claude Code Hermes OpenClaw
身份怎么定 §1 §1 §1
入口 / 唤起 §2 §2 §2
主循环 / ReAct §3 §3 §3
工具系统 §4 §4 §4
记忆 / 压缩 §5 §5 §5
输出 / 多端 §6 §6 §6
模型路由 §7 §7 §7
设计权衡 §8 §11 §8
短板 §0.5.3 §0.5.3 §0.5.3
源码索引 §9 §12 §9

#附录 A：术语对照表（三家概念冲突澄清）

新人最容易踩的坑是同一个词三家含义不同。下面把高频冲突词列出来：

词 Claude Code 里指 Hermes 里指 OpenClaw 里指
subagent / sub-agent / worker 独立 context 的子执行体，由父 agent 通过 Agent 工具 spawn sub-conversation 或 Kanban worker（跨进程） 默认在 Docker 沙箱里跑的隔离 sub-session
skill 一个 markdown 文件（描述 + body + 可选脚本），描述常驻 / body 用时进 一份 SKILL.md（程序性记忆 + frontmatter），由 agent 自己造 / 改 一个仓库内的工具包（5400+ 社区），有 frontmatter requires.env/bins
hook 27 个事件点 × 4 种 handler（command/http/prompt/agent），exit 2 强阻断 24+ plugin lifecycle hook（pre/post tool/llm, transform_llm_output…） hook 链就是软件总线（message:received / PreToolUse / PostToolUse / session:compact …）
memory 五层（System / CLAUDE.md / Auto MEMORY.md / skill / subagent） MEMORY.md + SQLite FTS5 + Honcho 用户画像 MEMORY.md + 按天分桩日记 + session jsonl
plugin 一种打包 hook / 工具的方式 5 种 kind（standalone / backend / exclusive / platform / model-provider）+ 4 级发现顺序 主要走 registerTool + bundle entry
session 一次对话的容器，可 --resume SQLite 行 + 可 fork 出 lineage 一个 jsonl 文件 + lane 锁
agent 配置文件 + 执行引擎组合 model + SKILL.md + 系统提示三件套 workspace + IDENTITY + SOUL
personality / soul （无对应） personality 文件（人物设定） SOUL.md（可在 ClawHub 流通的人格包）
channel / gateway surface（CLI / IDE / Web …） gateway adapter（20 平台） channel adapter（21 个 IM）

#附录 B：6 个必懂词的扩展阅读

读完 primer 还想再补基础的话，建议按顺序读这 6 个外部资源（都是免费的）：

  1. LLM 基础：Anthropic / OpenAI 官方 "what is an LLM" 文档
  2. system prompt 工程：Anthropic Prompt Engineering 指南
  3. tool calling：OpenAI function calling guide + Anthropic tool use guide
  4. ReAct paper："ReAct: Synergizing Reasoning and Acting in Language Models"（这是 agent 主循环的原始论文，2022 年）
  5. MCP 协议：modelcontextprotocol.io 的 spec + Anthropic 的介绍文章
  6. agent harness 概念：Anthropic 工程博客 "Building effective agents"（这篇定义了 model + harness 的拆分）

读完这 6 个，你就具备进任何一份长文的深度章节的能力了。

#一句话总结这份 primer

Agent = LLM（脑） + Harness（壳）。LLM 自己什么都不做，只输出"我想做什么"；Harness 真正去做。

Claude Code 把 Harness 做厚（权限 / hook / 多 surface）；Hermes 把 Harness 做薄（能下沉到模型权重的都下沉）；OpenClaw 把 Harness 做"长"（24×7 跑在用户机器上 + 多 IM）。

同一个 ReAct 主循环，三种压力，三种形态。读懂这一点，三份 1700 行的长文你就有了入门钥匙。

返回 Agent 资料库