agent 学习路径解析学习资源分享

文章目录

- [先给结论：你接下来不要优先读 GLM-4.5](#先给结论：你接下来不要优先读 GLM-4.5)
- [你对 agent 的轻视，有一半对，一半错](#你对 agent 的轻视，有一半对，一半错)
- [关于 Claude Code 泄露：你应该学"架构收获"，不要沉迷"源码猎奇"](#关于 Claude Code 泄露：你应该学“架构收获”，不要沉迷“源码猎奇”)
- [你提到的 learn-claude-code 仓库：值得看，而且现在就该看](#你提到的 learn-claude-code 仓库：值得看，而且现在就该看)
- 我给你的下一步路线：两条线并行，但主次分明
- - [主线：Claude Code-style harness，真刀真枪做](#主线：Claude Code-style harness，真刀真枪做)
  - [副线：GLM-4.5 速读，不精读](#副线：GLM-4.5 速读，不精读)
- 你应该建立的新知识地图
- [你要读的 agent 资料，不是"词汇集合文章"](#你要读的 agent 资料，不是“词汇集合文章”)
- - [路灯 1：Claude Code 官方文档](#路灯 1：Claude Code 官方文档)
  - [路灯 2：learn-claude-code](#路灯 2：learn-claude-code)
  - [路灯 3：Kimi K2 的 agent 部分回读](#路灯 3：Kimi K2 的 agent 部分回读)
  - [路灯 4：agent benchmark，不要只看分数，要看任务定义](#路灯 4：agent benchmark，不要只看分数，要看任务定义)
- [你接下来 14 天的具体安排](#你接下来 14 天的具体安排)
- - [第 1--2 天：建立最小 agent loop](#第 1–2 天：建立最小 agent loop)
  - [第 3--4 天：加入 edit 和测试闭环](#第 3–4 天：加入 edit 和测试闭环)
  - [第 5 天：加入 Todo](#第 5 天：加入 Todo)
  - [第 6--7 天：加入权限系统](#第 6–7 天：加入权限系统)
  - [第 8--9 天：加入 context compaction](#第 8–9 天：加入 context compaction)
  - [第 10--11 天：加入 subagent](#第 10–11 天：加入 subagent)
  - [第 12 天：加入 skills](#第 12 天：加入 skills)
  - [第 13 天：加入 memory](#第 13 天：加入 memory)
  - [第 14 天：写一篇面试 memo](#第 14 天：写一篇面试 memo)
- 面试官问你的时候，你应该这样讲
- - [问：什么是 harness agent？](#问：什么是 harness agent？)
  - [问：Claude Code 泄露你有什么收获？](#问：Claude Code 泄露你有什么收获？)
  - [问：skills 和 memory 有什么区别？](#问：skills 和 memory 有什么区别？)
  - [问：agent 和 workflow 有什么区别？](#问：agent 和 workflow 有什么区别？)
- 你的哲学困境，我给一个解法
- 最终建议
- [先说大判断：别人是怎么学 agent 的？](#先说大判断：别人是怎么学 agent 的？)
我给你的资源地图
- [第一层：必须读，解决"agent 到底怎么构建"](#第一层：必须读，解决“agent 到底怎么构建”)
- - [1. Anthropic《Building Effective Agents》](#1. Anthropic《Building Effective Agents》)
  - [2. Anthropic Academy / Claude Code / MCP 官方课程](#2. Anthropic Academy / Claude Code / MCP 官方课程)
  - [3. OpenAI Agents SDK 官方文档 + quickstart](#3. OpenAI Agents SDK 官方文档 + quickstart)
- [第二层：必须看，解决"Claude Code / harness 到底有什么真东西"](#第二层：必须看，解决“Claude Code / harness 到底有什么真东西”)
- - [4. Dive into Claude Code](#4. Dive into Claude Code)
  - [5. Claude Code 官方文档](#5. Claude Code 官方文档)
- 第三层：课程型资源，解决"我怎么系统补课"
- - [6. Stanford CS329A: Self-Improving AI Agents](#6. Stanford CS329A: Self-Improving AI Agents)
  - [7. DeepLearning.AI: AI Agents in LangGraph](#7. DeepLearning.AI: AI Agents in LangGraph)
  - [8. LangGraph / LangChain Academy](#8. LangGraph / LangChain Academy)
  - [9. Google 5-Day AI Agents Intensive / ADK Codelab](#9. Google 5-Day AI Agents Intensive / ADK Codelab)
- 第四层：框架与仓库，解决"我该拿什么做实验"
- - [10. OpenAI Agents SDK repo](#10. OpenAI Agents SDK repo)
  - [11. LangGraph repo](#11. LangGraph repo)
  - [12. Microsoft AutoGen / Agent Framework](#12. Microsoft AutoGen / Agent Framework)
  - [13. CrewAI](#13. CrewAI)
- [第五层：benchmark / eval，解决"agent 到底怎么证明自己有用"](#第五层：benchmark / eval，解决“agent 到底怎么证明自己有用”)
我给你的最终推荐排序
- [第 0 步：先读 Anthropic《Building Effective Agents》](#第 0 步：先读 Anthropic《Building Effective Agents》)
- [第 1 步：读 Dive into Claude Code](#第 1 步：读 Dive into Claude Code)
- [第 2 步：做你自己的 mini Claude Code](#第 2 步：做你自己的 mini Claude Code)
- [第 3 步：选一个框架重写](#第 3 步：选一个框架重写)
- - [选 LangGraph，如果你想理解长期状态和可恢复执行](#选 LangGraph，如果你想理解长期状态和可恢复执行)
  - [选 OpenAI Agents SDK，如果你想理解 tools、handoffs、guardrails、traces](#选 OpenAI Agents SDK，如果你想理解 tools、handoffs、guardrails、traces)
- [第 4 步：补 Stanford CS329A](#第 4 步：补 Stanford CS329A)
我不建议你现在优先看的资源
你的"路灯清单"
我给你的导师式路线

你的直觉是对的： 现在不应该继续顺着"大模型技术报告"惯性读 GLM-4.5 。
你现在的短板不是"不知道 GLM-4.5 又用了什么 MoE/RL/benchmark"，而是： 你缺少 agent harness 的真实工程手感 。

我会给你一个很明确的导师判断：

下一步主线：暂停纯模型报告阅读，转入 Claude Code / harness agent 的工程拆解与复现。GLM-4.5 只作为旁支速读，不作为主线。

原因很简单：Kimi K2 已经告诉你了，主流模型厂的 agent 叙事大概就是：更强 base model + tool-use 数据合成 + verifiable reward / self-critique RL + agent benchmark。Kimi K2 自己也说，它的 post-training 包括大规模 agentic data synthesis、真实/模拟环境交互、RLVR、自我批判奖励、agentic rollout、tool calling template 等等；但这些报告不会教你 Claude Code 这样的产品到底怎么跑起来。你读完会觉得"懂了，又没完全懂"，这是正常的。

先给结论：你接下来不要优先读 GLM-4.5

GLM-4.5 值得读，但不是现在精读。它会给你补充一个"主流大模型如何把 Agentic、Reasoning、Coding 放在同一框架里训练"的视角：GLM-4.5 报告声称模型通过 23T token 多阶段训练、expert model iteration 和 RL，在 TAU-Bench、AIME、SWE-bench Verified 上取得强结果。(arXiv)

但你已经被 Kimi K2 喂过类似东西了。你再读 GLM-4.5，大概率会继续得到：

text 复制代码

更大的/更聪明的模型
更多 coding 数据
更多 agent benchmark
一些 RL 后训练技巧
一些函数调用/工具调用模板

这些当然有价值，但它们解决不了你面试时被问的那类问题：

harness agent 是什么？

Claude Code 这种 agent 为什么能干活？

skills、memory、subagents、permissions、hooks 到底解决什么工程问题？

为什么不是"LLM + 一堆 if-else"？

agent 产品的核心壁垒到底在哪里？

这些问题，技术报告回答得很浅，工程系统回答得很深。

你对 agent 的轻视，有一半对，一半错

你说"我觉得他们就是大模型加上围绕的环境的系统工程罢了"。这句话很关键。

我会这样修正：

低级 agent 是 LLM + 系统工程。高级 agent 是：把模型能力、安全边界、上下文经济学、工具协议、状态管理、任务分解、失败恢复、权限系统、评估闭环全部压进一个可用产品的 harness。

也就是说，agent harness 不是"智能本身"，但它决定智能能不能变成生产力。

Kimi K2 的报告其实也在暗示这一点：它不仅训练模型，还专门讲了工具调用 token template、constrained decoding、真实/模拟环境、agentic rollout、partial rollout、Gym-like interface、真实代码 sandbox。这些不是模型参数，而是 agent 能不能稳定工作的外壳。

Claude Code 官方也把自己定义成一个可以读取代码库、跨文件修改、运行命令、集成开发工具的 agentic coding system。(Claude) 这正是 harness 的价值：让模型能感知代码库、行动、验证、恢复、继续。

关于 Claude Code 泄露：你应该学"架构收获"，不要沉迷"源码猎奇"

最近面试官问 "Claude Code 源码泄露你看了吗，有什么收获"，他们其实不是要你背 50 万行代码。他们想看你有没有意识到：

现代 coding agent 的核心竞争力，不只是模型，而是 harness。

公开安全分析称，Claude Code 曾因 npm 包里的 source map 暴露过大量 TypeScript 源码，相关分析提到 59.8MB source map、约 512K 行代码、约 1900 个文件级别的客户端 harness 暴露。(Zscaler)

你面试时可以这样回答：

我没有把泄露源码当作"抄代码"的材料，而是看公开分析和复现项目来理解 Claude Code 的 harness 设计。我的主要收获是：Claude Code 的壁垒不是某一个 prompt，而是一整套工程闭环，包括 agent loop、工具路由、权限门、上下文压缩、CLAUDE.md 项目记忆、subagents、hooks、MCP、任务状态和失败恢复。它本质上是在把 LLM 从 chat completion 包装成一个能在代码环境里长期行动的执行系统。

这个回答比"我看了源码，里面有 xxx 文件"更成熟。

你提到的 learn-claude-code 仓库：值得看，而且现在就该看

你给的仓库 shareAI-lab/learn-claude-code，我看了一下。它的定位很明确：不是教你训练模型，而是教你造 Claude Code-like agent harness 。仓库 README 直接强调 "Agency 来自模型，Agent 产品 = 模型 + Harness"，并把课程拆成 agent loop、工具使用、todo、subagent、skills、context compaction、permissions、hooks、memory、system prompt、任务系统、MCP 等章节。(GitHub)

这个仓库很适合你当前阶段，但我提醒你两点：

第一，它的开头有很强的观点输出，甚至有点宣言式。你不要被"哲学语言"带跑。你要把它当成 Claude Code harness pattern 练习册，不是当论文。

第二，不要从头到尾泛读。你要带着问题读：

text 复制代码

一个 coding agent 为什么需要 TodoWrite？
为什么需要 subagent，而不是让主 agent 一直干？
为什么需要 skills，而不是把所有说明塞进 system prompt？
为什么 memory 不能什么都存？
为什么权限系统是 agent harness 的核心，而不是附属功能？
为什么 context compaction 是长期任务的生命线？

如果你能回答这些问题，你面试 agent 岗位就有"粮食"了。

我给你的下一步路线：两条线并行，但主次分明

主线：Claude Code-style harness，真刀真枪做

你接下来 2 周，主线不是读报告，而是自己手搓一个最小 coding agent。

目标不是做出 Claude Code，而是做出一个你能在面试中讲清楚的系统：

text 复制代码

User task
  ↓
Agent loop
  ↓
Plan / Todo
  ↓
Tool selection
  ↓
Permission gate
  ↓
Execute tool
  ↓
Observation
  ↓
Update context / memory / todo
  ↓
Continue or stop

这才是你现在最缺的"实物感"。

你要按这个顺序学 learn-claude-code：

顺序	模块	你要真正理解的问题
1	s01 Agent 循环	什么叫 observation-action loop？
2	s02 工具使用	工具 schema、调用、结果回灌怎么设计？
3	s03 Todo 写入	为什么计划要显式化？
4	s06 上下文压缩	长任务为什么一定会 context 崩坏？
5	s07 权限系统	为什么 agent 的动作必须过 permission gate？
6	s04 子代理	为什么要隔离上下文？
7	s05 Skills	为什么知识要按需展开，而不是全塞 prompt？
8	s09 Memory	什么东西值得跨会话记住？
9	s08 Hooks	如何让系统扩展而不是污染主循环？
10	s19 MCP	外部工具生态怎么接进统一控制面？

这个站点自己的课程页也正好按类似路径拆成核心闭环、系统加固、任务运行时、多 agent 平台四层。(learn.shareai.run)

副线：GLM-4.5 速读，不精读

GLM-4.5 你可以读，但只读三部分：

Abstract / Introduction：看它如何定义 Agentic + Reasoning + Coding。
Post-training / RL / agent data：和 Kimi K2 做对比。
Evaluation：看 TAU-Bench、SWE-bench、agentic benchmarks 怎么评。

不要读架构细节超过半天。你现在不需要再沉迷"多少层、多少头、多少专家"。那些是模型组面试的粮食，不是 agent harness 岗位的主菜。

你应该建立的新知识地图

你之前的地图是：

text 复制代码

LLM 架构
预训练
SFT
RLHF / RLVR
推理模型
benchmark

现在要扩展成：

text 复制代码

模型能力
  ↓
工具协议
  ↓
agent loop
  ↓
上下文管理
  ↓
任务状态
  ↓
权限与安全
  ↓
环境交互
  ↓
执行反馈
  ↓
评估与改进

这张图里，模型只是一个节点。不是不重要，而是你已经在模型节点上积累够多了。你现在要补的是 模型周围那一圈"让它能干活"的东西。

你要读的 agent 资料，不是"词汇集合文章"

我给你分成四类。你只选一两个路灯就行。

路灯 1：Claude Code 官方文档

用途：建立产品真实边界。

读：

Claude Code Overview
Quickstart
Tools / permissions
Subagents
Hooks
Memory / CLAUDE.md
MCP

Claude Code 官方文档说它可以读取代码库、编辑文件、运行命令，并可在 terminal、IDE、desktop、web、JetBrains 等界面使用。(Claude) 这不是为了学"怎么用工具"，而是为了看 Anthropic 怎么把一个 coding agent 产品化。

你读官方文档时，只问一个问题：

这个功能解决了 agent loop 里的哪个具体失败模式？

比如：

功能	解决的失败模式
CLAUDE.md	项目规则反复丢失
Todo	长任务目标漂移
Subagents	主上下文污染、任务专业化不足
Hooks	工作流扩展不能全写死进主循环
Permissions	LLM 意图不能直接变成危险动作
MCP	工具生态不能靠硬编码无限扩展

路灯 2：learn-claude-code

用途：把文档变成可运行 mental model。

这个仓库最适合你现在的状态。它的课程页明确把 19 个章节拆成 agent loop、工具、todo、subagent、skills、context compaction、permissions、hooks、memory、task system、MCP 等。(learn.shareai.run)

你不要只看。你要每看一章做一个小实验。

例如看到 s02 工具使用，你就写一个最小工具路由器：

text 复制代码

available tools:
- read_file
- grep
- list_dir
- run_shell
- edit_file

agent decides:
- tool name
- arguments
- reason

system executes:
- permission check
- sandbox
- observation returned

看到 s06 context compaction，你就故意让 agent 做一个长任务，然后观察它如何忘记目标，再实现压缩摘要。

看到 s07 permissions，你就做 allowlist / denylist：

text 复制代码

允许：ls, cat, grep, python test.py
需要确认：rm, git push, curl, pip install
禁止：读取 ~/.ssh, 删除项目根目录, 外发 secret

这比你看十篇"AI Agent 未来已来"有用 100 倍。

路灯 3：Kimi K2 的 agent 部分回读

你觉得 Kimi K2 没收获，是因为你按"模型报告"的读法读它。现在换一种读法：把它当成 agent training 与 harness 的桥。

重点回读四处：

3.1.1 Agentic Data Synthesis：工具、agent、task、trajectory 怎么合成。
3.2 RL：verifiable rewards gym 和 self-critique reward。
3.3.4 Agentic Rollout：长 horizon、多轮环境交互、partial rollout。
Appendix B Tool Calling Template：工具声明、工具调用、工具结果的 token 协议。

这部分和 Claude Code harness 可以直接对上：

Kimi K2 报告	Claude Code harness
tool spec generation	工具 schema / MCP
trajectory generation	agent loop 日志
tool simulator	sandbox / fake environment
verifiable reward	test / compile / unit test
constrained decoding	tool call parser / enforcer
agentic rollout	多步执行任务

你之前觉得"不过如此"，是因为你还没有把这些东西实现一遍。实现以后你会发现：这些东西每一个都能出 bug，每一个都是工程壁垒。

路灯 4：agent benchmark，不要只看分数，要看任务定义

你现在要读 benchmark 的任务形式，而不是排行榜：

Benchmark	学什么
SWE-bench Verified	coding agent 如何从 issue 到 patch
Terminal-Bench	agent 如何在终端环境完成任务
τ-bench / τ2-bench	多轮工具调用与用户模拟
ACEBench	API grounding、tool learning、multi-turn tool use
PaperBench	长任务、研究复现、复杂执行链

Kimi K2 报告的 evaluation 部分已经把这些 benchmark 串在一起了，尤其是 SWE-bench、TerminalBench、τ2-Bench、ACEBench。你后面看模型报告时，不要只看"谁分高"，要看"这些 benchmark 迫使 agent 具备什么能力"。

你接下来 14 天的具体安排

第 1--2 天：建立最小 agent loop

目标：写出一个最小 coding agent，不要复杂。

功能：

text 复制代码

输入任务
模型生成下一步动作
执行工具
把 observation 回灌给模型
循环直到 done

你只需要 4 个工具：

text 复制代码

list_dir
read_file
grep
run_shell

你要能解释：

为什么 agent 不是一次性回答，而是 observation-action loop？

第 3--4 天：加入 edit 和测试闭环

新增：

text 复制代码

edit_file
run_tests

任务示例：

text 复制代码

给一个有 bug 的小 Python 项目，让 agent 找 bug、改代码、跑测试。

你要能解释：

为什么 coding agent 比普通 chat coding 强？因为它能执行、观察、修正，而不是只生成文本。

第 5 天：加入 Todo

实现一个可见 todo list。

要求 agent 每次长任务前写：

text 复制代码

1. Inspect project
2. Locate failing test
3. Understand root cause
4. Edit file
5. Run tests
6. Summarize

你要观察：没有 todo 的 agent 更容易漂移。

第 6--7 天：加入权限系统

实现：

text 复制代码

safe commands: ls, cat, grep, pytest
confirm commands: rm, pip install, git commit
deny commands: read ~/.ssh, curl secret, rm -rf

你要能面试回答：

LLM 的 tool call 只是意图，不是动作。harness 的责任是把意图转成受控动作。

这是 agent 岗最重要的一句话。

第 8--9 天：加入 context compaction

制造一个长任务，让上下文变长，然后做压缩：

text 复制代码

保留：
- 用户目标
- 已完成步骤
- 当前假设
- 修改过的文件
- 测试结果
- 下一步

丢弃：
- 冗余日志
- 失败尝试细节
- 重复文件内容

你要能解释：

压缩不是总结聊天记录，而是保留继续执行所需的工作记忆。

第 10--11 天：加入 subagent

做两个子代理：

text 复制代码

code-reviewer: 只读代码，找 bug，不改文件
test-runner: 运行测试，分析失败，不改业务代码

主 agent 负责分派和整合。

你要能解释：

subagent 的价值不是"多一个 prompt"，而是上下文隔离、角色专精、工具权限隔离。

第 12 天：加入 skills

做一个 skill：

text 复制代码

python-debugging-skill
- 如何读 traceback
- 如何定位 failing test
- 常见 pytest 命令
- 修改代码前先复现

要求：不是每次都塞进 prompt，而是任务相关时才加载。

你要能解释：

skills 是按需展开的专业知识包，解决上下文预算和专业化问题。

第 13 天：加入 memory

只存跨会话有用的信息：

text 复制代码

项目使用 pytest
用户偏好小步提交
这个 repo 的测试入口是 make test
不要存临时错误日志

你要能解释：

memory 不是垃圾桶。只有未来无法从当前上下文可靠推导的信息，才值得存。

第 14 天：写一篇面试 memo

题目：

Claude Code-style Agent Harness 的核心设计：从模型能力到可控行动

结构：

text 复制代码

1. Agent loop 是什么
2. Tool use 为什么需要 schema / parser / observation
3. Todo 如何防止目标漂移
4. Context compaction 如何延长任务 horizon
5. Permission gate 如何保证安全
6. Subagent / skill / memory 分别解决什么问题
7. 和 Kimi K2 agentic training 的关系
8. 我自己实现时遇到的失败案例

这篇 memo 就是你的面试弹药库。

面试官问你的时候，你应该这样讲

问：什么是 harness agent？

你答：

我理解 harness 不是 agency 本身，而是把模型放进环境中，让它能感知、行动、验证和恢复的一套运行时。模型负责生成意图，harness 负责提供工具、上下文、权限、安全边界、状态管理和执行反馈。Claude Code 这类系统的关键不是单次代码生成，而是围绕代码库形成 observation-action loop。

问：Claude Code 泄露你有什么收获？

你答：

我关注的不是源码细节，而是架构模式。公开分析显示 Claude Code 的客户端 harness 很大，说明真正的 coding agent 产品不是一个 prompt，而是一套复杂运行时。我的收获主要有五点：第一，工具调用必须有统一协议；第二，权限系统是核心，不是附属；第三，CLAUDE.md、memory、skills 解决的是上下文和长期偏好问题；第四，subagents 解决上下文隔离和专业化；第五，hooks / MCP 让系统可扩展，而不是把所有逻辑硬编码在主循环里。

问：skills 和 memory 有什么区别？

你答：

Skill 是可发现、可按需加载的能力包，解决"某类任务怎么做"的问题；memory 是跨会话持久状态，解决"这个用户/项目长期有什么事实或偏好"的问题。Skill 更像手册，memory 更像经验。二者都不能无脑塞上下文，否则会污染模型决策。

问：agent 和 workflow 有什么区别？

你答：

Workflow 是人写死流程，模型只填槽；agent 是模型根据 observation 选择下一步动作。两者可以结合，但判断标准是：下一步动作是由固定图决定，还是由模型根据环境反馈决定。

你的哲学困境，我给一个解法

你说：

不知道新东西就无法学习它，知道新东西又必须通过学习得到。

这个悖论在研究里很常见。解决方法不是"多看新闻"，而是建立 边界探针。

所谓边界探针，就是一个小实验、小复现、小 benchmark。它能告诉你：这个概念到底有没有肉。

对 agent 来说，你的边界探针就是：

text 复制代码

我能不能写一个 agent loop？
我能不能让它改代码并跑测试？
我能不能让它失败后恢复？
我能不能让它管理上下文？
我能不能让它安全地调用工具？
我能不能解释每个模块解决了哪个失败模式？

只要你开始做这些，迷雾会立刻变薄。因为 agent 这个领域的"深沉的东西"不在新闻里，也不完全在论文里，而在：

text 复制代码

一次工具调用失败
一次权限误放行
一次上下文污染
一次测试没跑却自称成功
一次 memory 存错导致长期行为偏移
一次 subagent 回答漂亮但不可验证

这些才是 agent 的真实知识。

最终建议

你现在选这两盏路灯：

主灯：learn-claude-code + 自己实现 mini Claude Code harness
副灯：Kimi K2 agent 部分回读 + GLM-4.5 agent/RL/eval 速读

顺序是：

text 复制代码

先做 harness
再回看 Kimi K2
再速读 GLM-4.5
再读 benchmark
再写面试 memo

不要再用"大模型技术报告"的学习方式学习 agent。

大模型报告适合吸收高密度事实；agent harness 适合通过失败建立理解。

你现在缺的不是更多名词，而是一个你亲手搭过、亲眼看它失败、亲手修过的 agent。

你这个担心是对的：只看一个仓库 + 自己实践，确实可能闭门造车。我替你重新扫了一圈，现在可以把 agent 学习资源分成 5 类。结论先说：

最适合你当前阶段的不是"泛 agent 入门课"，而是：Claude Code / coding agent 逆向分析 + Anthropic/OpenAI/Google 的官方 agent 工程资料 + 一个可落地框架课程。

你已经有 Kimi K2 和 learn-claude-code 两盏灯。我要再给你加 6 盏灯，但会区分主灯、副灯、观摩灯，避免你又掉进"收藏一堆资源但没有深入"的坑。

先说大判断：别人是怎么学 agent 的？

agent 领域和大模型不一样。大模型有清晰技术报告：模型规模、数据量、架构、训练阶段、benchmark。agent 没有这么单一的"总报告"，因为它更像系统工程 + 产品工程 + eval 工程。

其他人通常从这几类东西学：

text 复制代码

1. 厂商工程指南：Anthropic / OpenAI / Google / LangChain
2. 真实产品文档：Claude Code / Codex / Devin / Cursor / Copilot
3. 逆向分析：Claude Code leak / Dive into Claude Code
4. 框架实战：LangGraph / OpenAI Agents SDK / AutoGen / CrewAI
5. benchmark / eval：SWE-bench、Terminal-Bench、tau-bench、ACEBench

Kimi K2 报告其实已经暴露了这个趋势：它不是只讲模型，还讲工具调用模板、constrained decoding、agentic data synthesis、真实/模拟环境、sandbox、agentic rollout 和 RL infrastructure。换句话说，agent 的知识不只在模型报告里，而是在"模型如何进入环境"的那一整套系统里。

我给你的资源地图

第一层：必须读，解决"agent 到底怎么构建"

1. Anthropic《Building Effective Agents》

这是我认为你现在最该读的厂商文章 。它不是新闻，也不是营销文。Anthropic 明确区分 workflow 和 agent，并从 augmented LLM 开始，逐步讲到 prompt chaining、routing、parallelization、orchestrator-workers、evaluator-optimizer、autonomous agents。它的价值是帮你建立"什么时候该用 agent，什么时候不该用"的判断力。(Anthropic)

你读它时不要当教程读，要当设计准则读。重点回答：

text 复制代码

什么时候 workflow 比 agent 好？
什么时候让模型自主规划？
tool、retrieval、memory 到底是增强 LLM，还是 agent 本体？
agent 的复杂度应该如何渐进增加？

我建议你把它作为第一篇精读材料，优先级高于 GLM-4.5。

2. Anthropic Academy / Claude Code / MCP 官方课程

Anthropic 现在有官方学习资源，覆盖 AI Fluency、API development、MCP 和 Claude Code，并且有证书课程。这个值得看，因为它直接来自 Claude Code / MCP 的源头，而不是第三方转述。(Anthropic)

你不要泛学全部，重点看：

text 复制代码

Claude Code
Model Context Protocol
API tool use
Claude with tools / agents

这条线解决的是：Anthropic 自己希望开发者如何理解 Claude Code 和 MCP。

3. OpenAI Agents SDK 官方文档 + quickstart

OpenAI Agents SDK 官方文档现在把 agent 的核心部件拆得比较清楚：agent definition、tools、handoffs、guardrails、tracing、running agents、conversation state strategy。官方 quickstart 还特别提示你第一次跑通后要去 Traces dashboard 看 model calls、tool calls、handoffs 和 guardrails。(OpenAI开发者)

这个对你很有价值，因为它给你一个和 Claude Code 不同的抽象：

Claude Code 视角	OpenAI Agents SDK 视角
coding agent 产品	agent runtime / orchestration SDK
工具、权限、上下文、项目记忆	tools、handoffs、guardrails、traces
面向终端和代码库	面向通用 agent app

你应该用它来校准：哪些是 Claude Code 特有，哪些是 agent 通用结构。

第二层：必须看，解决"Claude Code / harness 到底有什么真东西"

4. Dive into Claude Code

这是你要补的最强"真刀真枪"资料之一。这个项目和论文声称对 Claude Code v2.1.88 做了源代码级架构分析，覆盖约 1,900 个 TypeScript 文件、约 512K 行代码，并总结出 agent 系统的设计空间。它强调：核心 agent loop 很简单，就是 model call → tool execution → repeat；真正复杂的是 loop 周围的系统，包括 permission system、context compaction、MCP、plugins、skills、hooks、subagent delegation、session storage 等。(GitHub)

这正好补你现在的困境：你看 Kimi K2 感觉不充实，因为它讲的是"模型训练如何支持 agent"；而 Dive into Claude Code 讲的是"agent 产品如何把模型能力转成可控执行"。

你读它时重点看这几个模块：

text 复制代码

1. agent loop
2. permission modes / safety classifier
3. context compaction pipeline
4. skills / hooks / MCP / plugins
5. subagent delegation
6. session storage
7. OpenClaw 对比

这是你面试 "Claude Code 泄露你怎么看" 的核心弹药。

5. Claude Code 官方文档

这不是"使用手册"那么简单。它是一个产品化 agent 的功能地图。Claude Code 官方文档把它描述为可以读取代码库、编辑文件、运行命令，并集成到 terminal、IDE、desktop、web 等环境里的 agentic coding system。(Claude)

你要按"失败模式"读文档：

功能	它解决的 agent 失败模式
CLAUDE.md / memory	项目约束和偏好丢失
permissions	模型意图直接变危险动作
hooks	用户工作流无法插入 agent loop
subagents	主上下文污染、任务专业化不足
skills	专业知识不能按需加载
MCP	工具生态硬编码、难扩展

你不是要成为 Claude Code 熟练用户，而是要知道它为什么长成这样。

第三层：课程型资源，解决"我怎么系统补课"

6. Stanford CS329A: Self-Improving AI Agents

这是偏研究生视角的课。课程说明是：研究能够通过和自身及环境交互而持续改进的 AI agents。(cs329a.stanford.edu)

它适合你，因为你不是只想会用 LangChain，而是想理解更高层问题：

text 复制代码

self-improvement
interaction with environment
experience
agent learning
long-horizon behavior

这门课我建议你放在"研究主线"，不是马上刷完。你可以先看 syllabus，把 lecture title 抄下来，建立 agent research map。

7. DeepLearning.AI: AI Agents in LangGraph

这是很适合工程入门的短课。它明确说会先从 Python + LLM 从零构建 agent，然后用 LangGraph 重建，学习组件如何组合成 flow-based applications。(DeepLearning.AI - Learning Platform)

这门课适合你做"从零到框架"的过渡。你现在不应该一上来就完全依赖框架，但你也不能永远手搓。正确路线是：

text 复制代码

先手搓 mini agent
再学 LangGraph
再回头理解 Claude Code 为什么不只是 LangGraph

8. LangGraph / LangChain Academy

LangGraph 官方把自己定位为 reliable agents 的 orchestration framework，强调 state、memory、human-in-the-loop 等能力。官方页面也提供 LangChain Academy 的免费基础课程。(LangChain)

LangGraph 的价值是：它不是教你"agent 很酷"，而是教你 stateful graph + durable execution。这正好对应 agent 的真实问题：

text 复制代码

状态怎么保存？
失败后怎么恢复？
human approval 怎么插入？
多个节点如何协作？
长任务如何 checkpoint？

你学 LangGraph 时不要沉迷 API，要抽象成：

agent = 状态机 + LLM 节点 + tool 节点 + human gate + persistence。

9. Google 5-Day AI Agents Intensive / ADK Codelab

Google 有两个值得看：一个是 Kaggle 上的 5-Day AI Agents Intensive，覆盖 models、tools、orchestration、memory、evaluation；另一个是 Google Agent Development Kit 的 codelab，教你搭建基础 conversational agent。(Kaggle)

这条线的价值是补齐 Google 生态的 agent 抽象。它不一定比 Anthropic/OpenAI 更适合你，但适合作为横向比较：

text 复制代码

Anthropic: Claude Code / MCP / effective agents
OpenAI: Agents SDK / Codex / tracing / guardrails
Google: ADK / Gemini / orchestration / codelabs
LangChain: LangGraph / stateful execution

第四层：框架与仓库，解决"我该拿什么做实验"

10. OpenAI Agents SDK repo

OpenAI 的 openai-agents-python 仓库现在是一个轻量但完整的 multi-agent workflow 框架，核心概念包括 agents、tools、guardrails、handoffs，也有 sandbox agents 和 examples。(GitHub)

你可以用它做一个实验：

text 复制代码

一个主 agent
一个 code-reviewer handoff
一个 test-runner handoff
一个 permission guardrail
一个 trace dashboard

目标不是学 SDK，而是体验：handoff、guardrail、trace 这些抽象为什么会出现。

11. LangGraph repo

LangGraph 官方仓库强调 long-running、stateful agents，并提到 Deep Agents 这类更高层包可以计划、使用 subagents、利用文件系统处理复杂任务。(GitHub)

LangGraph 适合做你的第二个实现版本：

text 复制代码

v1：手搓 while-loop coding agent
v2：用 LangGraph 改造成状态图
v3：加入 checkpoint / human approval / memory

这样你不会被框架牵着鼻子走。

12. Microsoft AutoGen / Agent Framework

AutoGen 现在已经演进到 Microsoft Agent Framework 1.0，定位是 enterprise-grade multi-agent orchestration，支持多模型、多 agent、A2A 和 MCP。(GitHub)

我对你的建议是：先不深学 AutoGen。你可以把它放在"多 agent 系统"的参考项。因为你当前最缺的是 coding harness 的工程闭环，不是多 agent 聊天室。

13. CrewAI

CrewAI 文档强调 crews、flows、guardrails、memory、knowledge、observability；它的 GitHub 也开始提供 official CrewAI Skills，让 Claude Code、Codex、Cursor、Windsurf 这类 coding agents 自动学习 CrewAI 最佳实践。(GitHub)

CrewAI 适合你观察一个现象：agent 框架自己也开始给 coding agents 写 skills。这说明 skills 正在变成新的"机器可读工程手册"。

但 CrewAI 不是你当前主线。它更偏 role-playing agents / business automation。你先知道它的位置即可。

第五层：benchmark / eval，解决"agent 到底怎么证明自己有用"

你不能只做 toy agent。agent 岗面试会越来越看重 eval。Kimi K2 报告的 evaluation 已经把 SWE-bench Verified、SWE-bench Multilingual、TerminalBench、τ2-Bench、ACEBench 等串起来了，并区分了 agentless single patch 和 agentic coding with bash/editor tools。

你要重点理解这些 benchmark：

Benchmark	你学到什么
SWE-bench Verified	从 GitHub issue 到 patch，coding agent 的核心战场
Terminal-Bench	终端环境里的多步执行能力
τ-bench / τ2-Bench	多轮用户-工具-环境交互
ACEBench	API-grounded tool use 和复杂工具调用
PaperBench	长任务、研究复现、复杂任务链

我建议你不要马上读所有 benchmark 论文。先做一个自己的 mini SWE-bench：

text 复制代码

准备 5 个小 bug
每个 bug 有 issue 描述
有 failing test
agent 需要读代码、定位、修改、跑测试
记录成功率、token、工具调用次数、失败原因

这比看排行榜更有用。

我给你的最终推荐排序

你接下来不要看 20 个资源。按这个顺序走。

第 0 步：先读 Anthropic《Building Effective Agents》

耗时：半天。

目的：建立 workflow vs agent 的判断力。

产出：一页笔记，标题是：

text 复制代码

什么时候该用 workflow，什么时候该用 agent？

第 1 步：读 Dive into Claude Code

耗时：2--3 天。

目的：理解 Claude Code-style harness 的真实结构。

产出：一张架构图：

text 复制代码

main loop
tools
permissions
context compaction
skills
hooks
MCP
subagents
memory/session

这一步比继续读 GLM-4.5 更重要。

第 2 步：做你自己的 mini Claude Code

耗时：1--2 周。

目的：用失败建立理解。

产出：一个 repo + 一篇面试 memo。

模块顺序：

text 复制代码

agent loop
read / grep / shell / edit tools
todo
permission gate
context compaction
subagent
skill
memory
trace / eval

第 3 步：选一个框架重写

我建议二选一：

选 LangGraph，如果你想理解长期状态和可恢复执行

LangGraph 更适合学习 state、memory、human-in-the-loop、durable execution。(LangChain)

选 OpenAI Agents SDK，如果你想理解 tools、handoffs、guardrails、traces

OpenAI Agents SDK 更适合做清晰的 agent runtime 实验。(OpenAI开发者)

不要两个都深学。你现在只能选一个。

我的建议：先 LangGraph，后 OpenAI Agents SDK 。

因为 LangGraph 会逼你理解状态机，而不是只把 agent 当 API wrapper。

第 4 步：补 Stanford CS329A

耗时：长期。

目的：从工程 agent 走向 research agent。

产出：研究问题列表。

你可以把课程里的每个主题变成一个问题：

text 复制代码

agent 如何从环境反馈中学习？
长期记忆如何评估？
self-improvement 会不会 reward hack？
agent eval 如何避免 benchmark overfitting？
多 agent 协作到底提升了什么？

我不建议你现在优先看的资源

不是说它们没用，而是现在不适合你。

资源	为什么不优先
Udemy 泛 Claude Code 课程	多数偏工具使用，不一定够深
Coursera 泛 autonomous agents	容易框架大杂烩
CrewAI 深学	容易走向 role-playing agents，不是 coding harness 主线
AutoGen 深学	多 agent 抽象重，可能分散你
GLM-4.5 精读	会继续给你模型训练视角，而不是 harness 手感
新闻/评论文章	信息密度太低，容易鬼打墙

GLM-4.5 可以保留为"周末速读"。你的主线应该切到 agent engineering。

你的"路灯清单"

我把它压缩成最值得点亮的 6 盏：

路灯	类型	你从中学什么	优先级
Anthropic Building Effective Agents	厂商设计指南	workflow vs agent、agent 模式	S
Dive into Claude Code	逆向/架构分析	Claude Code harness 真实结构	S
Claude Code 官方文档	产品文档	memory、skills、hooks、permissions、MCP	S
LangGraph / DeepLearning.AI	框架课程	stateful agent、graph、memory、HITL	A
OpenAI Agents SDK	官方 SDK	tools、handoffs、guardrails、tracing	A
Stanford CS329A	研究课程	self-improving agents、agent research map	A

你已经有的 learn-claude-code 仍然保留，但它现在不再是唯一主灯，而是和 Dive into Claude Code 搭配使用。

我给你的导师式路线

你现在不是缺资源，而是缺"资源编排"。我建议未来 3 周这样做：

text 复制代码

第 1--2 天：
读 Anthropic Building Effective Agents
写 workflow vs agent 判断笔记

第 3--5 天：
读 Dive into Claude Code
画 Claude Code harness 架构图

第 6--12 天：
手搓 mini Claude Code
至少支持 read/grep/edit/shell/test/todo/permission

第 13--16 天：
加入 context compaction / skill / memory
记录失败案例

第 17--20 天：
用 LangGraph 重写核心 loop
理解 state、checkpoint、human-in-the-loop

第 21 天：
写面试 memo：
"我如何理解 Claude Code-style coding agent harness"

这条路走完，你不会再觉得 agent 是新闻词汇集合。你会知道每个词背后的失败模式。

最后我给你一个判断标准：
一个 agent 资料是否值得读，不看它有没有讲"自主、规划、记忆"，而看它有没有回答：状态怎么保存？工具怎么约束？失败怎么恢复？上下文怎么压缩？任务怎么评估？权限怎么设计？

能回答这些的，是深资料。

只喊 autonomous、multi-agent、AGI、workflow revolution 的，先放一边。

这里是引用读了kimi k2感觉没什么太大收获。无非是 muonclip、强化学习阶段构造agentic data来为后续agent打基础。接下来读哪一篇我有点犹豫。我感觉k2没有带给我充实的感觉。近期面试经常被面试官问=harness agent claude code源代码泄露，你看了吗有什么收获= 我现在想到的是是不是可以来点真刀真枪的agent的东西学一下？目前面临的困境，你读了之后从更高的角度帮我做决策，你现在是我的导师。 1 继续读GLM-4.5: Agentic, Reasoning, and Coding 继续了解主流大模型最新进展也挺好或许能学新东西 2 最近在面试agent岗位遇到很多agent问题感觉有点无米之炊但是这玩意的技术报告到底是否存在我没什么底，至少大模型技术报告在我认知里面是如数家珍的。agent这东西现在脑海里都是新闻概念=龙虾、 harness、Claude code= 真要说学习我还有点看不上他们，我觉得他们就是大模型加上围绕的环境的系统工程罢了。或许我应该直接开始实践？有可能边实践我就知道他们的skills memory的可贵之处了。这是在我脑海里面已经知道的仓库 https://github.com/shareAI-lab/learn-claude-code/blob/main/README-zh.md 你帮我看看怎么样 3 哲学思考：我深刻感受到自己处于知识边界。学习新东西是个矛盾。你不知道新东西你就无法学习它，你知道新东西是必须通过学习得到的。如此产生悖论。我一直在大模型 agent门口打转，没有深入的重要原因就是生活中会见到大模型相关新闻，评论文章一百次，但是真正的深沉的东西不语，静静的等着我去发掘。比如说看技术报告很爽的一点在于信息密度高，大口大口的吮吸大模型的知识。多少层，多少头，参数量多少，训练数据量多少，这些几分钟学到的比看一百篇新闻还有用。我希望你可以帮助我拓展知识边界，找到学习agent的最好方法。我前方是重重迷雾，我需要你帮我清晰展开这附近所有的可以学习的资源，帮助我一步一步解开迷雾，我选择一两个你为我点亮的知识路灯，我就能够很好的走下去。如果没有实质性的学习资料辅助，我可能只是在鬼打墙（看agent词汇集合文章，和大模型浅浅交流，实则没什么用处）

agent 学习路径解析 学习资源分享

文章目录

先给结论：你接下来不要优先读 GLM-4.5

你对 agent 的轻视，有一半对，一半错

关于 Claude Code 泄露：你应该学"架构收获"，不要沉迷"源码猎奇"

你提到的 learn-claude-code 仓库：值得看，而且现在就该看

我给你的下一步路线：两条线并行，但主次分明

主线：Claude Code-style harness，真刀真枪做

副线：GLM-4.5 速读，不精读

你应该建立的新知识地图

你要读的 agent 资料，不是"词汇集合文章"

路灯 1：Claude Code 官方文档

路灯 2：learn-claude-code

路灯 3：Kimi K2 的 agent 部分回读

路灯 4：agent benchmark，不要只看分数，要看任务定义

你接下来 14 天的具体安排

第 1--2 天：建立最小 agent loop

第 3--4 天：加入 edit 和测试闭环

第 5 天：加入 Todo

第 6--7 天：加入权限系统

第 8--9 天：加入 context compaction

第 10--11 天：加入 subagent

第 12 天：加入 skills

第 13 天：加入 memory

第 14 天：写一篇面试 memo

面试官问你的时候，你应该这样讲

问：什么是 harness agent？

问：Claude Code 泄露你有什么收获？

问：skills 和 memory 有什么区别？

问：agent 和 workflow 有什么区别？

你的哲学困境，我给一个解法

最终建议

先说大判断：别人是怎么学 agent 的？

我给你的资源地图

第一层：必须读，解决"agent 到底怎么构建"

1. Anthropic《Building Effective Agents》

2. Anthropic Academy / Claude Code / MCP 官方课程

3. OpenAI Agents SDK 官方文档 + quickstart

第二层：必须看，解决"Claude Code / harness 到底有什么真东西"

4. Dive into Claude Code

5. Claude Code 官方文档

第三层：课程型资源，解决"我怎么系统补课"

6. Stanford CS329A: Self-Improving AI Agents

7. DeepLearning.AI: AI Agents in LangGraph

8. LangGraph / LangChain Academy

9. Google 5-Day AI Agents Intensive / ADK Codelab

第四层：框架与仓库，解决"我该拿什么做实验"

10. OpenAI Agents SDK repo

11. LangGraph repo

12. Microsoft AutoGen / Agent Framework

13. CrewAI

第五层：benchmark / eval，解决"agent 到底怎么证明自己有用"

我给你的最终推荐排序

第 0 步：先读 Anthropic《Building Effective Agents》

第 1 步：读 Dive into Claude Code

第 2 步：做你自己的 mini Claude Code

第 3 步：选一个框架重写

选 LangGraph，如果你想理解长期状态和可恢复执行

选 OpenAI Agents SDK，如果你想理解 tools、handoffs、guardrails、traces

第 4 步：补 Stanford CS329A

我不建议你现在优先看的资源

你的"路灯清单"

我给你的导师式路线

agent 学习路径解析学习资源分享