Skip to main content

什么是智能？从感知到行动的完整闭环

智能不是"知道答案"，而是"完成任务"

一个问题​

当你说 ChatGPT "很智能"的时候，你在说什么？

  • 它能回答问题？
  • 它能写代码？
  • 它能理解你的意图？

这些都对，但都不够准确。

真正的问题是：ChatGPT 能帮你完成一个完整的任务吗？

比如：

  • "帮我重构 query.ts，提取 5 个函数"
  • "修复测试失败的 bug"
  • "优化这段代码的性能"

答案是：不能。

ChatGPT 只能"建议"你怎么做，但不能"执行"。你需要：

  1. 把代码复制给它
  2. 看它的建议
  3. 手动修改代码
  4. 运行测试
  5. 如果失败，再复制错误信息给它
  6. 重复 2-5

这个过程可能需要 30 分钟，来回 10 轮。

而 Claude Code 或 Codex 这样的 Agent，能在 2 分钟内自动完成。

为什么？

因为 ChatGPT 只有"智能"的一部分，而 Agent 有"智能"的完整闭环。

智能的完整闭环​

什么是智能？

智能 = 完成任务的能力

不是"知道答案"，而是"做出来"。

要完成任务，需要一个完整的闭环：

感知环境 → 理解信息 → 做出决策 → 执行行动 → 获得反馈 → 调整策略

这个闭环缺一不可。

人类的智能闭环​

以"修复 bug"为例，人类是怎么做的？

  1. 👀 感知：用眼睛看代码、看错误信息
  2. 🧠 理解：大脑分析问题原因
  3. 💭 决策：判断应该怎么修改
  4. ✋ 行动：用手敲键盘，修改代码
  5. 🔄 反馈：运行测试，看结果
  6. 🔁 调整：如果还是失败，回到步骤 2

这是一个完整的闭环。

每个环节都不可或缺：

  • 没有"感知"，你看不到代码
  • 没有"理解"，你不知道问题在哪
  • 没有"决策"，你不知道怎么改
  • 没有"行动"，你改不了代码
  • 没有"反馈"，你不知道改对了没有
  • 没有"调整"，你无法优化方案

这就是智能的本质：一个完整的闭环。

LLM 的局限：残缺的闭环​

现在看看 ChatGPT（或任何 LLM）：

能力人类LLM说明
👀 感知✅ 眼睛❌只能"读文本"，看不到真实世界
🧠 理解✅ 大脑✅强大的语言理解能力
💭 决策✅ 大脑✅能做出合理判断
✋ 行动✅ 手❌只能"输出文本"，不能执行
🔄 反馈✅ 看结果❌不知道执行结果
🔁 调整✅ 持续优化❌无法根据结果调整

LLM 只有"理解"和"决策"，缺少"感知"、"行动"、"反馈"、"调整"。

这就是为什么 ChatGPT 只能"建议"，不能"执行"。

真实对比：修复 Bug​

用 ChatGPT：

你：为什么测试失败？
ChatGPT：可能是以下原因：
  1. 变量未初始化
  2. 类型不匹配
  3. 异步问题
  
你：（手动检查每个可能）
你：我检查了，是类型不匹配
ChatGPT：那你需要修改第 42 行...
你：（手动修改）
你：（手动运行测试）
你：还是失败，错误是 XXX
ChatGPT：那可能是...
...（重复 10 轮）

时间：30 分钟
成功率：60%（可能最后还是没修好）

用 Agent（Claude Code / Codex）：

你：修复测试失败

Agent：
1. [Read] 读取测试文件
2. [Bash] 运行测试，看错误信息
3. [Read] 读取相关代码
4. [分析] 发现类型不匹配
5. [Edit] 修改第 42 行
6. [Bash] 再次运行测试
7. [成功] 测试通过

时间：2 分钟
成功率：95%

差距：15 倍

Agent 如何补全闭环​

Agent = LLM + 工具 + 循环

能力LLMAgent如何实现
👀 感知❌✅通过工具"看到"文件、代码、系统状态
🧠 理解✅✅LLM 的能力
💭 决策✅✅LLM 的能力
✋ 行动❌✅通过工具执行真实操作（Read/Write/Bash）
🔄 反馈❌✅看到执行结果（工具返回值）
🔁 调整❌✅多轮循环，根据结果调整策略

1. 感知：通过工具"看到"世界​

LLM 只能"读文本"，Agent 通过工具能"看到"：

  • Read 工具：读取文件内容
  • Grep 工具：搜索代码
  • Bash 工具：运行命令，看输出
  • Git 工具：查看代码历史

例子：

// Claude Code 的 Read 工具
await tools.Read({ file_path: "src/query.ts" })
// 返回：文件内容（2330 行代码）

// Codex 的 read_file 工具
read_file("src/query.ts")
// 返回：文件内容

2. 行动：通过工具"执行"操作​

LLM 只能"输出文本"，Agent 通过工具能"执行"：

  • Write 工具：创建文件
  • Edit 工具：修改文件
  • Bash 工具：运行命令
  • Git 工具：提交代码

例子：

// Claude Code 的 Edit 工具
await tools.Edit({
  file_path: "src/query.ts",
  old_string: "const x = 1",
  new_string: "const x = 2"
})

// Codex 的 str_replace 工具
str_replace("src/query.ts", "const x = 1", "const x = 2")

3. 反馈：看到执行结果​

每个工具调用都有返回值：

  • Read：返回文件内容
  • Edit：返回"修改成功"或错误信息
  • Bash：返回命令输出（stdout/stderr）

Agent 能"看到"这些结果，就像人类看到屏幕输出一样。

4. 调整：多轮循环优化​

Agent 不是"一次性执行"，而是"持续循环"：

// Claude Code 的核心循环（简化版）
while (true) {
  // 1. 调用 API，获取决策
  const response = await callAPI()
  
  // 2. 如果没有工具调用，说明任务完成
  if (!response.tool_calls) break
  
  // 3. 执行工具
  const results = await executeTools(response.tool_calls)
  
  // 4. 把结果反馈给 LLM
  // 下一轮循环时，LLM 会看到这些结果
}

关键：每一轮都能看到上一轮的结果，根据结果调整策略。

为什么闭环重要？​

没有闭环：AI 是"顾问"​

ChatGPT 就像一个"顾问"：

  • 你问它问题
  • 它给你建议
  • 你自己执行
  • 你自己看结果
  • 你再问它

问题：

  • 累（需要手动执行）
  • 慢（来回 10 轮）
  • 容易出错（手动操作）
  • AI 看不到中间结果（无法优化）

有了闭环：AI 是"执行者"​

Agent 就像一个"执行者"：

  • 你给它任务
  • 它自己执行
  • 它自己看结果
  • 它自己调整
  • 它完成任务

优势：

  • 快（自动执行）
  • 准（能看到结果，能纠错）
  • 省心（你只需要等结果）

真实案例：重构代码​

任务：重构 query.ts，提取 3 个函数

ChatGPT（无闭环）​

你：帮我重构 query.ts，提取 3 个函数

ChatGPT：
我建议提取以下函数：
1. queryLoop() - 处理循环逻辑
2. executeTools() - 执行工具
3. handleResponse() - 处理响应

你可以这样做：
[给出代码示例]

你：（复制代码，手动修改）
你：（运行测试）
你：测试失败了，错误是 XXX

ChatGPT：
那你需要修改...
[给出新建议]

你：（再次手动修改）
...

时间：10 分钟
体验：累

Agent（有闭环）​

你：重构 query.ts，提取 3 个函数

Agent：
[Read] 读取 query.ts
[分析] 识别可提取的函数
[Edit] 提取 queryLoop()
[Edit] 提取 executeTools()
[Edit] 提取 handleResponse()
[Bash] 运行测试
[成功] 测试通过

时间：30 秒
体验：省心

智能的本质​

回到最开始的问题：什么是智能？

智能不是"知道答案"，而是"完成任务"。

要完成任务，需要：

  1. 感知：看到环境
  2. 理解：分析信息
  3. 决策：判断方案
  4. 行动：执行操作
  5. 反馈：看到结果
  6. 调整：优化策略

这是一个完整的闭环，缺一不可。

LLM 只有"理解"和"决策"，所以它只能"建议"。

Agent 补全了闭环，所以它能"执行"。

这就是为什么 Agent 比 LLM 强大 10 倍的根本原因。

下一篇预告​

现在你理解了"什么是智能"。

但还有一个问题：Agent 的智能是怎么放大的？

为什么同样是 GPT-4 或 Claude，加上工具和循环，智能就能放大 10 倍？

这不是简单的"加法"（100 + 10 = 110），而是"乘法"（100 × 10 = 1000）。

为什么是乘法？

下一篇文章会深入分析：《Agent 智能的本质：不是更大的模型，而是完整的能力》

关键要点​

  1. 智能 = 完成任务的能力，不是"知道答案"
  2. 智能闭环：感知 → 理解 → 决策 → 行动 → 反馈 → 调整
  3. LLM 的局限：只有"理解"和"决策"，缺少其他环节
  4. Agent 补全闭环：通过工具实现"感知"和"行动"，通过循环实现"反馈"和"调整"
  5. 效率差距：Agent 比 ChatGPT 快 10-15 倍，成功率高 30%+

记住：没有闭环，AI 只是"顾问"；有了闭环，AI 才是"执行者"。

字数：约 3200 字
阅读时间：约 8 分钟