第1章：AI Agent 到底是个啥？

一句话：搞清楚 Agent 是什么、能干什么、和普通聊天机器人有什么区别。

本章目标

理解 AI Agent 的本质
区分 Agent 和普通聊天机器人的区别
了解 Agent 的三大核心能力
对当前 Agent 生态有个基本认知

前置知识

无，这是第一章

1.1 从聊天机器人说起

你一定用过 ChatGPT

如果你用过 ChatGPT，你大概知道它是这么工作的：你问一个问题，它给你一个回答。你再问一个，它再回一个。一来一回，就像发微信聊天。

这看起来挺厉害的对吧？确实厉害。但你有没有试过让它帮你干点"实事"？

比如你跟 ChatGPT 说：

"帮我订一份外卖，黄焖鸡米饭，送到公司。"

它会怎么回答？大概是这样的：

"好的，你可以按照以下步骤操作：

打开美团/饿了么 App

搜索黄焖鸡米饭

选择一家评分高的店

填写配送地址

下单支付

需要我帮你推荐几家好吃的店吗？"

看到问题了吗？它只是在教你怎么做，而不是帮你去做。它给了你一份操作指南，但外卖还是得你自己去点。

这就是普通聊天机器人的局限性 —— 它只会说，不会做。

Agent 不一样 —— 它说到做到

现在想象一下另一个场景。你对一个 AI Agent 说：

"帮我把项目里所有的 console.log 都删掉。"

Agent 会怎么做？它不会给你写一份教程告诉你"你可以用 VS Code 的全局搜索替换功能"。它会直接动手：

先搜索项目里所有包含 console.log 的文件
逐个文件打开，找到 console.log 那一行
判断这行能不能直接删（有些 console.log 可能是有用的日志）
删掉不需要的那些
告诉你："已完成，共删除了 23 处 console.log，保留了 3 处带有 // keep 注释的日志。"

看出区别了吗？

一个精准的比方

想象你是一个公司老板：

ChatGPT 像一个超级聪明的参谋（军师）：

你问他"竞争对手最近在干什么"，他能给你分析得头头是道
你问他"我该怎么提高销量"，他能给你列出十条建议
但你说"那你去把方案执行了吧" —— 他做不到，他只能动嘴，不能动手

Agent 像一个既聪明又能干的秘书（执行助理）：

你说"帮我安排下周二和李总的会议"，它直接去查你的日历、查李总的空闲时间、订会议室、发邀请邮件，全都做了
你说"帮我把这份报告润色一下"，它直接打开文件、修改内容、保存，搞定
它不光能想，还能动手干活

再来几个对比的例子

你的需求	ChatGPT 的回应	Agent 的回应
"帮我查一下这个 Bug 是哪里引起的"	"可能是 xxx 原因，你可以检查 xxx 文件"	直接搜索代码、定位到具体文件和行号、分析原因、甚至帮你修好
"帮我写个脚本，每天自动备份数据库"	给你一段代码，让你自己保存和配置	创建脚本文件、设置定时任务、测试运行、确认一切正常
"这个项目的代码质量怎么样？"	给你一些评估的思路和建议	扫描所有文件、统计代码行数、检查命名规范、找出潜在问题、生成一份完整的报告
"帮我搭建一个新项目"	告诉你应该安装什么、配置什么	直接创建目录、初始化项目、安装依赖、写好配置文件、跑通第一个示例

一句话总结这个区别：

ChatGPT 是"嘴上说说"，Agent 是"说到做到"。

1.2 Agent 的三大核心能力

好，现在你知道 Agent 和普通聊天机器人的区别了 —— Agent 不光能说，还能做。那问题来了：Agent 是怎么做到的？它靠什么"超能力"？

答案是三个核心能力，缺一不可。我们一个一个来看。

🧠 能力一：思考（Thinking）

Agent 的思考能力来自于大语言模型（LLM），比如 Claude、GPT-4。

这个"大脑"能做什么？

理解你的意思：你说"帮我把代码里那些没用的注释清理一下"，它能理解"没用的注释"是什么意思 —— 比如被注释掉的旧代码、过时的 TODO、无意义的分隔线注释等
制定计划：它会想："我应该先找到所有的注释，然后判断哪些是有用的、哪些是没用的，然后只删除没用的那些"
做出判断：看到 // 这是一个临时的解决方案，后面要重构 这种注释，它会判断这条是有用的，应该保留

生活中的类比： 这就像你脑子里的"想法"。你饿了，你的大脑会想："我要吃饭 → 冰箱里有什么 → 可以做个蛋炒饭 → 需要鸡蛋和米饭"。Agent 的大语言模型就是它的大脑，负责想清楚要干什么、怎么干。

🔧 能力二：行动（Acting）

光会想有什么用？得能动手啊！Agent 通过调用工具来执行具体的操作。

这在技术上叫做 Tool Use（工具调用）或 Function Calling（函数调用）。听起来很专业，其实很简单 —— 就是 Agent 可以"按按钮"来做事情。

Agent 能用的工具包括（但不限于）：

工具	能干什么	就像人类的...
读文件（Read）	打开一个文件看里面写了什么	眼睛
写文件（Write）	创建或修改一个文件	手
执行命令（Bash）	在终端里跑命令	操作电脑
搜索文件（Glob）	在项目里找特定的文件	在书架上找书
搜索内容（Grep）	在文件里搜关键词	在书里查关键词
搜索网页（WebSearch）	上网搜索信息	用搜索引擎

生活中的类比： 你的大脑想好了"做蛋炒饭"，然后你的手去开冰箱、拿鸡蛋、打火、炒饭。工具就是 Agent 的"手"，让它能把想法变成行动。

这里有一个关键点：Agent 不是什么工具都有的。你需要告诉它"你可以用哪些工具"。就像你给新来的实习生分配工位 —— 你可以给他一台电脑，也可以再给他打印机的权限，但你不会把公司服务器的管理员密码也给他。

🔄 能力三：自主循环（Agentic Loop）

这个是最关键的，也是 Agent 和普通 API 调用最大的区别。

什么叫"自主循环"？简单说就是：干完一步，看看结果，决定下一步干什么，然后继续干，直到任务完成。

整个过程是一个循环：

  思考："我应该先做什么？"
    ↓
  行动：调用工具，执行操作
    ↓
  观察：看看结果怎么样
    ↓
  思考："做完了吗？下一步该干什么？"
    ↓
  行动：继续调用工具...
    ↓
  观察：再看看结果...
    ↓
  ...（循环继续）
    ↓
  完成："好了，任务搞定，给你结果。"

生活中的类比： 你在打扫房间。你不是一开始就把所有步骤都想好的。你先扫地，扫完发现桌上还很乱，就去整理桌子。整理桌子的时候发现有几本书应该放到书架上，就去放书。放书的时候发现书架上灰很多，就擦一下书架。每一步做什么，都是你根据当前的情况动态决定的。

Agent 也是这样工作的。它不是一开始就写好了一个固定的脚本，然后按部就班执行。它是在执行过程中不断思考、不断调整的。这就是"智能"的体现。

三大能力缺一不可

让我们把三个能力放在一起看：

  ┌──────────────────────────────────────────────┐
  │              Agent 的核心架构                  │
  │                                               │
  │   🧠 思考（LLM）                              │
  │   "我理解你的需求了，让我想想该怎么做..."        │
  │         │                                     │
  │         ▼                                     │
  │   🔧 行动（Tools）                             │
  │   "好，我先用搜索工具找到相关文件..."            │
  │         │                                     │
  │         ▼                                     │
  │   🔄 循环（Loop）                              │
  │   "搜到了3个文件，让我看看内容..."              │
  │   "第一个文件有问题，我来修一下..."              │
  │   "改好了，还有2个文件，继续..."                │
  │   "全部搞定！向你汇报结果。"                    │
  │                                               │
  └──────────────────────────────────────────────┘

没有思考：Agent 就像一个只会按指令操作的机器人，不能理解复杂的需求
没有行动：Agent 就退化成了 ChatGPT，只能说不能做
没有循环：Agent 就只能做一步就停了，不能处理需要多步骤的复杂任务

三者结合，才构成了一个真正的 AI Agent。

1.3 一个生活化的例子

光说理论太抽象了，让我们来看一个完整的例子，感受一下 Agent 到底是怎么工作的。

你的需求

你对 Agent 说：

"帮我找出这个项目里所有的 TODO 注释，整理成一个清单，保存到 todo-list.md 文件里。"

Agent 的"内心独白"

让我们钻进 Agent 的脑子里，看看它是怎么一步一步完成这个任务的：

第1轮 —— 思考

Agent 心想：

"用户想让我找 TODO 注释。我需要先搜索项目里所有包含 'TODO' 的文件。用什么工具呢？Grep 最合适，它能在文件内容里搜索关键词。"

第1轮 —— 行动

Agent 调用 Grep 工具：

工具：Grep
参数：搜索 "TODO" 关键词，搜索范围是整个项目

第1轮 —— 观察

Grep 返回结果：

src/index.ts:15:    // TODO: 添加错误处理
src/index.ts:42:    // TODO: 这里需要优化性能
src/utils.ts:8:     // TODO: 支持更多文件格式
src/utils.ts:23:    // TODO(urgent): 修复内存泄漏
tests/test.ts:5:    // TODO: 补充边界测试用例
config.ts:12:       // TODO: 从环境变量读取配置

第2轮 —— 思考

Agent 心想：

"找到了 6 个 TODO。让我仔细看看每一个的内容和位置，然后整理成一个有组织的清单。我可以按文件分组，还应该把那个标记了 'urgent' 的放在显眼的位置。"

第2轮 —— 行动

Agent 调用 Write 工具，创建 todo-list.md：

工具：Write
参数：
  文件路径：todo-list.md
  内容：（Agent 自己组织的 Markdown 格式清单）

写入内容：

# 项目 TODO 清单

> 自动生成时间：2025-01-15

## 紧急 (Urgent)

- [ ] **修复内存泄漏** - `src/utils.ts:23`

## 功能改进

- [ ] 添加错误处理 - `src/index.ts:15`
- [ ] 优化性能 - `src/index.ts:42`
- [ ] 支持更多文件格式 - `src/utils.ts:8`
- [ ] 从环境变量读取配置 - `config.ts:12`

## 测试

- [ ] 补充边界测试用例 - `tests/test.ts:5`

---
共计 6 项待办事项，其中 1 项紧急。

第2轮 —— 观察

Write 工具返回：文件创建成功。

第3轮 —— 思考

Agent 心想：

"文件创建好了。让我验证一下文件是不是真的写进去了，内容对不对。"

第3轮 —— 行动

Agent 调用 Read 工具：

工具：Read
参数：读取 todo-list.md 文件

第3轮 —— 观察

Read 返回了文件内容，和它刚才写入的一致。

最终回复

Agent 对你说：

"已完成！我在项目里找到了 6 个 TODO 注释，已整理成清单保存到 todo-list.md。其中有 1 个标记了 urgent 的紧急事项（内存泄漏修复），我把它单独放在了最上面。"

注意看这几个关键点

Agent 自己决定用什么工具：你没告诉它用 Grep，它自己判断 Grep 最合适
Agent 自己决定执行步骤：你没告诉它先搜索再写文件再验证，它自己规划了这个流程
Agent 会主动做额外的事：你没让它把 urgent 的提到前面，但它自己判断这样更有用
Agent 会验证自己的工作：写完文件后它主动去检查了一遍
整个过程是多轮循环：不是一次就完事，而是经历了 3 轮"思考→行动→观察"

这就是 Agent 的魅力 —— 你只需要说清楚你想要什么，它自己搞定怎么做。

1.4 Agent vs 普通 API 调用

可能你会想：这和我直接调 ChatGPT 的 API 有什么区别？不都是发请求、收回复吗？

区别大了去了。让我画个图给你看。

普通 API 调用：一问一答

你：────── 请求 ──────→  LLM  ────── 回复 ──────→ 你
         "帮我分析一下             "这段代码有
          这段代码"                 3个问题..."

         完事了，结束。

流程很简单：

你发一条消息
LLM 回一条消息
结束

如果你想让它接着干活（比如"那帮我修一下"），你得自己再发一次请求。每一步都需要你来推动。

Agent 调用：自主循环

你："帮我找到代码里的 Bug 并修好"
 │
 ▼
┌─────────────────────────────────────────┐
│            Agent 循环开始                │
│                                         │
│  ┌─────────┐                            │
│  │  思考    │ "我先搜索可疑的代码..."     │
│  └────┬────┘                            │
│       ▼                                 │
│  ┌─────────┐                            │
│  │  行动    │  调用 Grep 搜索错误模式     │
│  └────┬────┘                            │
│       ▼                                 │
│  ┌─────────┐                            │
│  │  观察    │ "找到了 2 处可疑代码"       │
│  └────┬────┘                            │
│       ▼                                 │
│  ┌─────────┐                            │
│  │  思考    │ "让我仔细看看第一处..."     │
│  └────┬────┘                            │
│       ▼                                 │
│  ┌─────────┐                            │
│  │  行动    │  调用 Read 读取文件内容     │
│  └────┬────┘                            │
│       ▼                                 │
│  ┌─────────┐                            │
│  │  观察    │ "确认是个空指针 Bug"        │
│  └────┬────┘                            │
│       ▼                                 │
│  ┌─────────┐                            │
│  │  思考    │ "我知道怎么修了"           │
│  └────┬────┘                            │
│       ▼                                 │
│  ┌─────────┐                            │
│  │  行动    │  调用 Edit 修改代码         │
│  └────┬────┘                            │
│       ▼                                 │
│  ┌─────────┐                            │
│  │  观察    │ "修改成功"                 │
│  └────┬────┘                            │
│       ▼                                 │
│  ┌─────────┐                            │
│  │  思考    │ "还有第二处，继续..."       │
│  └────┬────┘                            │
│       ▼                                 │
│      ...（继续循环）                     │
│       ▼                                 │
│  ┌─────────┐                            │
│  │  完成    │ "两个 Bug 都修好了！"       │
│  └─────────┘                            │
│                                         │
└─────────────────────────────────────────┘
 │
 ▼
你（收到最终结果）

看到关键区别了吗？

核心区别总结

维度	普通 API 调用	Agent
交互模式	一问一答	自主循环
谁来推动	你（开发者）写代码驱动每一步	Agent 自己驱动
能做多少步	1步	无限步（直到完成）
能用工具吗	不能（或者你自己写代码调工具）	能，Agent 自己选工具
能处理复杂任务吗	不能（除非你自己编排）	能，Agent 自己编排
代码量	多（你得写循环、写工具调用、写判断）	少（你只需要说清楚需求）

为什么循环是关键创新？

你可能会说："我自己写个循环不就行了？在代码里 while 一下，不断调 API，不就变成 Agent 了？"

理论上是这样，但关键在于谁来做决策。

如果是你写的循环，那每一步做什么、什么时候停下来、遇到异常怎么办，都得你提前在代码里写好。你得预见所有可能的情况，写一大堆 if-else。

而 Agent 的循环，决策者是大语言模型。它能理解当前的上下文，动态决定下一步做什么。遇到意料之外的情况，它也能灵活应对，因为它有"理解力"和"判断力"。

这就好比：

自己写循环 = 你提前写好了一份详细的操作手册，让一个人照着做。如果遇到手册没写到的情况，他就懵了。
Agent 循环 = 你请了一个有经验的人来做事。你只需要告诉他目标，他自己知道该怎么一步步完成，遇到问题也能自己想办法。

1.5 当前 Agent 生态一览

现在你知道 Agent 是什么了。那目前市面上有哪些做 Agent 的框架和产品呢？让我们来看看这个生态圈。

Agent 开发框架

这些是你用来构建 Agent 的工具包，就像你盖房子用的砖头和水泥。

1. Anthropic 的 Claude Agent SDK（本教程的主角）

这是 Anthropic 公司（就是做 Claude 的那个公司）推出的官方 Agent 开发框架。

核心理念：简单到极致。整个 SDK 的核心就一个函数 query()，传入你的需求，它就开始干活
特点：内置了文件操作、命令执行、网页搜索等常用工具，开箱即用
地位：Claude Code（Anthropic 的官方编程助手）就是用这个 SDK 构建的
适合谁：想快速构建 Agent 应用的开发者，不想折腾复杂框架的人

2. OpenAI 的 Agents SDK

OpenAI（做 GPT 的公司）推出的 Agent 框架。

特点：和 OpenAI 的模型深度绑定，支持 Handoffs（Agent 之间交接任务）
适合谁：已经在用 OpenAI 生态的团队

3. LangChain / LangGraph

开源社区最流行的 Agent 框架之一。

LangChain：提供了大量预制组件，像乐高积木一样拼装 Agent
LangGraph：LangChain 的升级版，用"图"的方式定义 Agent 的工作流
特点：功能非常丰富，支持几十种模型和上百种工具
适合谁：需要高度定制化、需要支持多种模型的团队
吐槽：有时候太复杂了，学习曲线比较陡

基于 Agent 框架构建的产品

上面那些是"砖头水泥"，下面这些是用砖头水泥盖出来的"房子"。

1. Claude Code

Anthropic 官方出品的 AI 编程助手。

定位：命令行里的编程搭档
能做什么：读代码、写代码、改代码、跑测试、管理 Git、搜索文件...几乎所有编程相关的事情它都能帮你干
底层引擎：就是 Claude Agent SDK
地位：可以说是目前最强大的 AI 编程工具之一

2. OpenClaw

一个非常成熟的开源 AI 助手平台。

代码量：约 43 万行代码（没错，43 万行）
GitHub 星标：超过 22.4 万颗星，非常受欢迎
支持的消息渠道：15 个以上，包括 Telegram、WhatsApp、Discord、Slack、微信等等
核心优势：模型无关（Model-agnostic），你可以用 Claude、GPT、Llama 等任何模型
适合谁：需要一个功能完整、支持多渠道的 AI 助手平台

3. NanoClaw

一个极简主义的 AI 助手，受到 Claude Agent SDK 启发。

代码量：大约 500 行，没错，只有 500 行
核心思路：把 Claude Agent SDK 的 query() 跑在 Docker 容器里，加上即时通讯渠道接入
容器隔离：每个对话在独立的 Docker 容器或 Apple Container 中运行，安全可靠
底层引擎：Claude Agent SDK
适合谁：想要一个简单、安全、可以快速上手的私人 AI 助手

4. ZeroClaw

一个追求极致性能的 AI 助手。

编程语言：Rust（以性能和安全著称的语言）
部署形式：单个二进制文件，直接运行，不需要装一堆依赖
硬件要求：可以在 10 美元的硬件上运行
适合谁：需要在资源有限的环境中部署 AI 助手的场景

生态全景图

┌────────────────────────────────────────────────────┐
│                   Agent 生态全景                     │
│                                                     │
│  ┌── 模型层 ──────────────────────────────────┐     │
│  │  Claude  │  GPT-4  │  Llama  │  Gemini     │     │
│  └──────────────────────────────────────────────┘    │
│                      ↕                               │
│  ┌── 框架层 ──────────────────────────────────┐     │
│  │  Claude Agent SDK │ OpenAI SDK │ LangChain  │     │
│  └──────────────────────────────────────────────┘    │
│                      ↕                               │
│  ┌── 协议层 ──────────────────────────────────┐     │
│  │                MCP 协议                      │     │
│  │  （让 Agent 连接任何外部工具的统一接口）        │     │
│  └──────────────────────────────────────────────┘    │
│                      ↕                               │
│  ┌── 产品层 ──────────────────────────────────┐     │
│  │  Claude Code │ OpenClaw │ NanoClaw │ ZeroClaw│     │
│  └──────────────────────────────────────────────┘    │
│                      ↕                               │
│  ┌── 用户层 ──────────────────────────────────┐     │
│  │  开发者  │  团队  │  企业  │  个人用户       │     │
│  └──────────────────────────────────────────────┘    │
│                                                     │
└────────────────────────────────────────────────────┘

1.6 为什么选择 Claude Agent SDK？

市面上这么多 Agent 框架，为什么我们这套教程选择 Claude Agent SDK 呢？

理由一：它是 Claude Code 的"同款引擎"

Claude Code 是目前最强大的 AI 编程助手之一。而 Claude Agent SDK 就是它背后的引擎。

这意味着什么？意味着这个 SDK 是经过实战检验的。Anthropic 自己的旗舰产品就在用它，你可以放心它的质量和稳定性。

类比一下：这就像丰田把自己赛车上用的发动机技术开放给普通消费者了。赛场上验证过的东西，质量能差吗？

理由二：API 简单到令人感动

整个 SDK 的核心就围绕一个函数 —— query()。

你不需要学一堆复杂的概念，不需要理解什么"链"、"图"、"状态机"。一个 query() 函数，传入你的需求和配置，它就开始工作了。

# 伪代码，感受一下简洁程度
result = query("帮我把项目里的 Bug 找出来修好")

对比 LangChain，你可能需要定义 Chain、Memory、Agent、Tool、Prompt Template 等一堆东西。Claude Agent SDK 把这些全都封装好了。

理由三：内置工具开箱即用

SDK 自带了常用的工具：

文件读写（Read、Write、Edit）
命令执行（Bash）
文件搜索（Glob、Grep）
网页搜索和抓取（WebSearch、WebFetch）
子任务委派（Task）
用户交互（AskUserQuestion）

你不需要自己去封装这些基础能力，拿过来就能用。

理由四：MCP 协议连接万物

MCP（Model Context Protocol）是 Anthropic 发明的开放协议，让 Agent 可以连接任何外部工具。

社区已经做了上百个 MCP Server，覆盖了 GitHub、数据库、Slack、文件系统、Docker 等等。你的 Agent 想用什么工具，只要有对应的 MCP Server，插上就能用。

更厉害的是，MCP 现在已经不只是 Anthropic 在推了 —— OpenAI、Google 等公司都开始支持 MCP。这意味着它正在成为行业标准。

理由五：支持多 Agent 协作

当一个 Agent 搞不定的时候，你可以派多个 Agent 一起干。Claude Agent SDK 原生支持 Subagent（子 Agent），你可以轻松搭建一个"Agent 团队"。

比如：

主 Agent 负责理解需求、分配任务
代码审查 Agent 专门看代码质量
测试 Agent 专门写测试用例
文档 Agent 专门写文档

每个 Agent 可以用不同的模型、不同的工具、不同的系统提示词，各司其职。

理由六：Anthropic 在积极开发

这不是一个被扔出来就不管了的开源项目。Anthropic 在积极维护和更新这个 SDK，不断添加新功能。

最近它们还发布了 TypeScript V2 预览版，引入了更简洁的 Session-based API。可以预见，这个 SDK 会越来越好用。

总结对比

特性	Claude Agent SDK	OpenAI Agents SDK	LangChain
学习难度	低	中	高
API 复杂度	一个核心函数	中等	较复杂
内置工具	丰富	基础	需要自己组装
多 Agent	原生支持	支持	需要 LangGraph
MCP 支持	原生	有限	通过插件
实战产品	Claude Code	ChatGPT	各种应用
模型支持	Claude 系列	GPT 系列	几乎所有

如果你的目标是"快速学会构建 AI Agent，做出实用的东西"，那 Claude Agent SDK 是目前最好的选择之一。

动手练习

这一章没有代码练习（下一章也没有，从第 3 章才开始写代码）。但有两个思考练习，帮你把学到的东西和你的实际工作联系起来。

练习1：想一想你的日常工作

拿出一张纸（或者打开一个笔记 App），想一想你平时工作中有哪些重复性的、步骤明确的任务，是可以让 Agent 帮你做的。

至少列出 3 个。

举几个例子帮你启发思路：

"每天早上检查项目有没有新的 Issue，整理成一个日报"
"每次提交代码前，自动检查代码风格和潜在 Bug"
"把产品经理写的需求文档，自动转换成技术任务清单"
"监控服务器日志，发现异常自动告警"
"每周自动生成项目进度报告"

你的三个任务是什么？写下来。

练习2：分析 Agent 需要什么工具

对于你在练习1中列出的每个任务，想一想 Agent 需要哪些工具才能完成。

用这个格式来分析：

任务：每天早上检查新 Issue，整理成日报

需要的工具：
1. GitHub API 工具 —— 查询最新的 Issues
2. 读文件工具 —— 读取之前的日报格式作为模板
3. 写文件工具 —— 把新的日报写入文件
4. （可选）发消息工具 —— 把日报发到群聊里

Agent 需要的"思考"：
- 判断哪些 Issue 是今天新增的
- 按优先级排序
- 用合适的格式整理

对你列出的每个任务都做一次这样的分析。这个练习的目的是让你开始用 Agent 的思维方式思考问题。以后你在学习 SDK 的时候，就会知道每个功能对应你的什么需求。

本章小结

让我们回顾一下这一章学到了什么：

Agent 和普通聊天机器人的区别：聊天机器人只能说（给建议），Agent 能说也能做（直接执行）。Agent 就像一个既能动脑又能动手的秘书。
Agent 的三大核心能力：
- 🧠 思考：由大语言模型（LLM）提供，负责理解需求、制定计划
- 🔧 行动：通过工具调用（Tool Use）来执行具体操作
- 🔄 自主循环：干完一步看结果、决定下一步，不断循环直到任务完成
Agent vs 普通 API 调用：普通 API 是"一问一答"模式，你得自己推动每一步；Agent 是"自主循环"模式，你只需要说清楚目标，它自己搞定过程。
当前 Agent 生态：
- 框架层有 Claude Agent SDK、OpenAI Agents SDK、LangChain 等
- 产品层有 Claude Code、OpenClaw、NanoClaw、ZeroClaw 等
- MCP 协议正在成为连接 Agent 和外部工具的行业标准
为什么选 Claude Agent SDK：简单（一个核心函数）、实战验证（Claude Code 同款引擎）、工具丰富（内置 + MCP 扩展）、多 Agent 支持。

下一章预告

下一章我们要拆开 Agent 的引擎盖，看看里面到底是怎么运转的。

我们会深入了解：

Agentic Loop（代理循环）：Agent 的心脏是怎么跳动的
Tools（工具）：Agent 是怎么知道该用哪个工具的
Context（上下文）：Agent 的记忆是怎么工作的
LLM（大语言模型）：Agent 的大脑到底在做什么

不写代码，纯聊原理。用做饭、公司管理、打游戏这些生活化的比喻，帮你彻底搞懂 Agent 的内部工作机制。

搞懂了原理，后面写代码的时候你就不是"照抄"，而是"理解了再写"，遇到问题也知道该从哪里下手排查。

我们下一章见！