什么是 Agent？

一篇综述：把 30 年的 Agent 概念史、Anthropic / OpenAI / Google 的现代定义、Claude Code 与 Codex 的源码实现，以及"Chat → Agent"范式转移的产业影响，全部收在一篇文章里。

本文同步发布于：blog: 2026-04-18--what-is-agent

---

TL;DR

• Agent 不是新概念：1995 年罗素 & 诺维格（Russell & Norvig）的 AI 教材里就定义了。它一直缺一个零件：通用推理引擎。
• LLM 就是那个零件：Agent = LLM（大脑）+ Tools（手脚）+ Memory（记忆）+ Loop（自驱）。
• 三家定义背后是三种世界观：Anthropic 押安全工程（MCP，模型上下文协议）、OpenAI 押SDK 平台（Agents SDK）、Google 押Agent 互联协议（A2A，智能体互联协议）。
• 核心实现是一个 30 行循环：所有 Agent 内核都是 ReAct loop。Claude Code 用 AsyncGenerator 写在 800 行 TS 里，Codex 用 Rust + tokio 写得更分布式。
• 真正的工程壁垒不在循环：在工具系统、权限模型、沙箱、错误恢复、上下文压缩、多 Agent 编排。
• 范式转移正在发生：用户从"操作者"变成"委托者"，软件从"被动响应"变成"主动推进"。GUI 不会死，但会从"操作界面"变成"审查界面 + 协作界面 + 生成产物"。

---

1. 一个开场场景

小李是个产品经理，今天早上被老板派了一个活：

"把上个季度所有用户反馈拉出来，按主题分类，找出 top 3 痛点，写成 PRD 草稿，下午 4 点要。"

放在两年前，小李得：导 CSV → 手打标签 → 自己读自己归类 → 套模板写 PRD → 祈祷不要被插需求。

放在今天，小李打开 Claude Code，敲一句：

"去 ./feedback 拉数据，按主题聚类，找出最高频的 3 个痛点，按 ./templates/prd.md 生成草稿，写到 ./drafts/q2-prd.md。"

然后他去倒了杯咖啡。回来的时候文件已经在那里了。

这个东西，就叫 Agent。

它不是更聪明的 ChatGPT。它是一种完全不同形态的软件——你给它目标，它自己想办法把活干完。

---

2. 这个词不是 OpenAI 发明的，1995 年就有了

很多人以为 Agent 是 ChatGPT 之后冒出来的新概念。错。

Agent 这个词在 AI 教材里躺了整整 30 年。

1995 年，斯图尔特·罗素（Stuart Russell）和彼得·诺维格（Peter Norvig）的《人工智能：一种现代的方法》（Artificial Intelligence: A Modern Approach）——AI 圈的圣经——开篇就在讲 Agent：

An agent is anything that can perceive its environment through sensors and acting upon that environment through actuators.

按这个定义，恒温器、扫地机器人、追激光的猫都是 Agent。

那为什么直到 2024 年，"Agent"才突然炸了？

因为缺了一个零件。整整缺了 30 年。

把那本教材里的 Agent 框架简化成流程：

观察环境 → 理解发生了什么 → 决定下一步做什么 → 执行 → 看结果 → 再循环

第 1、4、5 步，传统软件 30 年前就能做。真正卡死所有人的是第 2、3 步——"理解"和"决定"。

过去要做这两步只有两条路：硬编码规则（脆得不行）或专门训练模型（成本天花板锁死）。所以 Agent 一直只能做"窄域"任务。

类比：1995 年你已经有完整的汽车设计图——底盘、车轮、变速箱全都画好了。但没有发动机。LLM 出现之前，Agent 就是这台没发动机的车。

---

3. LLM 是发动机，但 LLM 自己不是车

LLM 出现后，所有人发现它有 5 个硬伤：

硬伤	表现
① 知识截止	不知道最近发生的事
② 幻觉	编不存在的 API
③ 没有副作用	能告诉你怎么改文件，不能改
④ 上下文有限	几十 K token 后就忘
⑤ 被动	你不问，它不动

单独一个 LLM，是个天才但残疾的大脑——能想，不能动，不能记，不能查证。

而 30 年前那张 Agent 设计图，正好就是给这种大脑配的"义肢"：

LLM（大脑）
  + Tools（手脚 → 解决"不能动"+"不能查证"）
  + Memory（记忆 → 解决"上下文有限"）
  + Loop（自驱循环 → 解决"被动"）
  + Knowledge / RAG（外部知识 → 解决"知识截止"）
= Agent

所以"Agent"不是 LLM 时代的新发明，而是 LLM 把 30 年前那张设计图救活了。

发动机来了，车终于能上路了。

---

4. 三家公司的定义，背后是三种世界观

4.0 先把术语理清：Agent vs Agentic vs Agency

词	词性	含义
Agent	名词	一个完整的系统/实体（非黑即白）
Agentic	形容词	具有 Agent 特质的程度（光谱）
Agency	名词（抽象）	主体性、能动性（自己做决定的能力）

Agentic 不是 Agent 的形容词形式。它来自心理学/哲学的 agency（主体性），核心是"自己做决定、自己采取行动"。

关键区别：

Agent  = 一个具体的东西（是 / 不是）
Agentic = 一种程度（完全不 → 完全是）

光谱举例：

• 完全不 agentic：传统 SaaS 表单
• 有点 agentic：自动补全
• 比较 agentic：GitHub Copilot
• 很 agentic：Claude Code
• 完全 agentic：Devin

所以可以说"这个产品越来越 agentic 了"，但不会说"这个产品越来越 agent 了"。

——这个区分会让下面三家定义立刻变清晰。

4.1 Anthropic：警惕概念膨胀，提出 "Agentic Systems" 伞概念

Building effective agents 给出了行业最严谨的切分：

"We use 'agentic systems' as an umbrella term, but draw an important architectural distinction between workflows and agents."

Agentic systems（伞概念）
  ├── Workflow：LLM 和工具被预定义代码路径编排
  └── Agent：LLM 动态决定自己用什么工具、走什么路径

洞见：一个东西可以是 agentic 的，但不是 agent。Workflow 就是这种情况。

立场：Don't build agents when a workflow will do.

为什么？因为 Agent 的代价是可预测性的崩溃——你不知道它下一步会调什么 API、改什么文件、花多少 token。Workflow 慢但稳，Agent 快但野。

OpenAI：把 Agent 做成 SDK

Practical Guide to Building Agents 直接亮出 SDK 三件套：

Instructions  —— 你是谁、目标是什么
Model         —— 哪个 LLM 在驱动你
Tools         —— 你能调什么

世界观：Agent 是新的"应用形态"，平台要把 SDK / 协议 / 托管全包了。

Google：押"多 Agent 协作"

Agents 白皮书 把 Agent 拆成三层认知架构（Cognitive Architecture）：

┌─────────────────────────────────────┐
│  Orchestration Layer                 │ ← 维护状态、决策循环
├─────────────────────────────────────┤
│  Model                               │ ← LLM
├─────────────────────────────────────┤
│  Tools (其他 Agent 也是 Tool)        │
└─────────────────────────────────────┘

紧接着推 A2A (Agent-to-Agent，智能体互联协议)——让 Agent 之间互相调用的开放标准。

世界观：未来不是一个超级 Agent，而是无数个专业 Agent 通过协议组成网络。

三家放一起看

	Anthropic	OpenAI	Google
核心立场	谨慎 / 工程化	平台化 / SDK	网络化 / 协议
关键押注	MCP（工具协议）	Agents SDK + Responses API	A2A（Agent 协议）
想成为	Agent 工程范式	Agent 时代的 AWS	Agent 时代的 Web

---

5. Agent 到底长什么样？

所有 Agent，去掉花哨的包装之后，都是这个循环——叫 ReAct (Reasoning + Acting)：

while not done:
    # 1. 给 LLM 看当前对话历史 + 可用工具列表
    # 2. LLM 输出：要么是最终答案，要么是工具调用
    response = llm.call(messages, tools)

    if response.is_tool_use:
        result = execute_tool(response.tool, response.args)
        messages.append(result)
        continue

    if response.is_final_answer:
        done = True

就这十几行伪代码。Agent 的灵魂全在这里。

关键设计：

• "决策"不是程序员写的 if-else，而是 LLM 在每轮里实时生成的
• "循环"由模型自己决定何时停
• "工具"不固定——你可以给它 1 个、10 个、100 个，它自己挑

这个循环来自 2022 年姚顺雨（Shunyu Yao）等人的 ReAct 论文。

今天市面上你听过的所有 Agent——Claude Code、Codex、Cursor、Devin、AutoGPT、Manus——内核全是这个循环的变体。

---

6. 源码拆解 ① ：Claude Code 是怎么写的

读 540K 行 Claude Code 源码之后，结论是：

它的核心循环就是一个 800 行的 TypeScript 异步生成器函数。

6.1 主循环

文件位置：src/query.ts 中的 queryLoop：

// src/query.ts
async function* queryLoop(
  params: QueryParams,
  consumedCommandUuids: string[],
): AsyncGenerator<...> {
  let state: State = {
    messages: params.messages,
    toolUseContext: params.toolUseContext,
    autoCompactTracking: undefined,
    turnCount: 1,
    // ... 一堆状态
  };

  // 主查询用 while(true) 驱动多轮，属故意写法
  while (true) {
    const response = await callModel(state);

    for await (const chunk of response) {
      yield chunk;

      if (chunk.type === 'tool_use') {
        const result = await executeTool(chunk);
        state.messages.push(result);
      }
    }

    if (state.transition === 'done') break;
    state.turnCount++;
  }
}

去掉错误处理、token 计数、context 压缩、interrupt 处理，剩下就是 ReAct 循环——几乎一比一对应。

6.2 关键设计 1：用 AsyncGenerator 实现流式 + 可中断

为什么用 async function*？

因为 Agent 跑一个任务可能要 30 秒、3 分钟、30 分钟。用户必须能：

1. 实时看到中间过程（流式输出）
2. 随时按 Ctrl+C 打断（cancellation）
3. 在中间插入新指令（interrupt）

AsyncGenerator 一次性解决三件事——每 yield 一次都是可被外部观察、可被外部打断的检查点。

6.3 关键设计 2：工具不是函数，是声明式接口

interface Tool {
  name: string;
  description: string;
  inputSchema: ZodSchema;
  isReadOnly(): boolean;            // 只读还是会改文件？
  needsPermissions(): boolean;      // 需不需要弹权限确认？
  call(input, context): AsyncGenerator;
  renderToolUseMessage(input);
  renderResultForAssistant(...);
}

注意 isReadOnly 和 needsPermissions。这是 Agent 工程化的灵魂——

读文件不需要确认，但删文件、跑命令、推 Git 必须弹框。这一层"权限边界"，单独的 LLM 做不到，必须由 Agent 框架强制实现。这是单 LLM 和 Agent 的本质区别之一。

6.4 关键设计 3：Task.ts 暴露的"野心"

export type TaskType =
  | 'local_bash'
  | 'local_agent'
  | 'remote_agent'
  | 'in_process_teammate'
  | 'local_workflow'
  | 'monitor_mcp'
  | 'dream'              // ← 这是什么？

'dream' 是一个还没正式 release 的能力——让 Agent 在 idle 时自己"做梦"，主动思考用户接下来可能要什么。

你看到的 Claude Code 是个 CLI。源码里它已经在准备做：多 Agent 协作 + 远程托管 + 后台主动思考。

---

7. 源码拆解 ② ：Codex 走了完全不同的路

如果 Claude Code 是"用 TypeScript 把 Agent 写成流式应用"，Codex 就是 "用 Rust 把 Agent 写成分布式系统"。

7.1 主循环

codex-rs/core/src/tasks/regular.rs：

let mut next_input = input;
let mut prewarmed_client_session = prewarmed_client_session;
loop {
    let last_agent_message = run_turn(
        Arc::clone(&sess),
        Arc::clone(&ctx),
        next_input,
        prewarmed_client_session.take(),
        cancellation_token.child_token(),
    )
    .instrument(run_turn_span.clone())
    .await;

    if !sess.has_pending_input().await {
        return last_agent_message;
    }
    next_input = Vec::new();
}

run_turn 的源码注释直接讲明白了模型协议：

At each sampling request, the model replies with either:
- requested function calls
- an assistant message

If the model requests a function call, we execute it and send the output
back to the model in the next sampling request.
If the model sends only an assistant message, we record it in the
conversation history and consider the turn complete.

注释本身就是 ReAct 循环的英文版定义。

7.2 关键设计 1：Arc<Session> —— 多 Agent 共享会话

Arc::clone(&sess) 这个动作很关键。Arc（原子引用计数）意味着 session 可以被多个并发任务安全共享。

Codex 在 agent/role.rs 里有专门的 Agent Role 抽象——你可以在同一会话里，让不同 sub-agent 用不同 system prompt、不同工具集干活。

主 agent 拆任务，sub-agent 跑代码，第三个 agent 写测试。所有这些共享一份 session 上下文——这才是真正的多 Agent 系统。

7.3 关键设计 2：System prompt 是独立 Markdown 文件

打开 codex-rs/core/gpt-5.2-codex_prompt.md：

You are Codex, based on GPT-5. You are running as a coding agent in the Codex CLI on a user's computer.

## General
...

整个 Agent 的"人格"——叫什么、在哪儿、怎么思考、能做什么不能做——全在这个 Markdown 里。

这是 Agent 工程一个反直觉的事实：

单看代码，你看不到 Agent 在"想"什么。 Agent 的思维方式 90% 写在那个 Markdown system prompt 里。 这个文件改一行，Agent 整个行为模式都会变。

Prompt 不是"附属物"，prompt 就是 Agent 的程序。

7.4 关键设计 3：每个工具 = Rust 模块 + OS 沙箱

codex-rs/core/src/tools/
  bash.rs           # 跑 shell 命令
  file_read.rs      # 读文件
  file_edit.rs      # 编辑文件
  agent.rs          # 调子 Agent
  monitor.rs        # 长任务监控
  ...

而且 Codex 把"沙箱"做到 OS 层面——Linux 用 seccomp，macOS 用 sandbox-exec 把 Agent 隔离起来。

因为它想清楚了一件事：你不能让一个会自主调 shell 的程序，直接跑在用户的 root 权限下。

这种"安全工程"，是 Agent 走出 demo、走进生产环境的硬门槛。

---

8. 把两边放一起看，会得到一个洞见

维度	Claude Code	Codex
语言	TypeScript	Rust
核心循环载体	AsyncGenerator	tokio + channel
多 Agent 协作	TaskType 枚举（早期）	Arc<Session> + Agent Role（更深）
隔离	进程级 hook + 权限确认	OS-level sandbox
Prompt 管理	TS 字符串 + 模板拼接	独立 Markdown 文件
偏向	表达力	性能 + 安全

但两边的内核循环几乎一致：

while (没结束) {
  let response = 调 LLM(messages, tools)
  if (response 是工具调用) 执行工具 → 塞回 messages
  if (response 是最终答案) break
}

这是当下整个 Agent 行业的共识架构。

差异都在外围——隔离做得多狠、上下文压得多紧、流式做得多稳、多 Agent 怎么协调。

洞见：

如果你 2026 年想做 Agent 创业，技术壁垒不在那个核心循环（30 行代码搞定）， 而在那些让循环能在生产环境扛住的东西： 工具系统设计、权限模型、沙箱、错误恢复、流式控制、上下文压缩、多 Agent 编排……

核心循环是免费的。工程化是护城河。

---

9. Chat → Agent，软件正在被重写

9.1 用户和软件的关系，从"操作"变成"委托"

	Chat 范式	Agent 范式
用户角色	操作者	委托者
输入	一步一步指令	一个目标
软件	被动响应	主动推进
时间尺度	秒级	分钟到小时
验证方式	看每一步	看最终交付物

这是一次**"主体性"的让渡**。

9.2 软件设计的所有底层假设都在被推翻

• UI 是给人看的 → 错。Agent 时代 UI 一半给人看一半给 Agent 看
• 交互是同步的 → 错。Agent 任务是 5 秒～5 小时的长尾
• 用户每一步都看得到 → 错。中间可能调了 50 次 API、改了 30 个文件
• 每个 SaaS 是独立产品 → 错。Agent 同时调 Slack + Notion + Jira + GitHub
• Per-seat 定价 → 错。1 个 Agent 干 50 个人的活，定价模型直接崩

9.3 GUI 不会死，但角色会变

未来更可能是：90% 输入是自然语言，10% 是必要的人工触点；90% 输出有 GUI，但 GUI 是用来"看"和"改"，不是用来"操作"。

GUI 的新职能：

1. 审查界面（看 Agent 干了什么）
2. 协作界面（人和 Agent 一起做某些必须人在场的事）
3. 生成产物（很多最终交付本身就是 GUI——比如 dashboard）

---

10. 一句话总结

Agent 不是更强的 ChatGPT，Agent 是软件的下一种形态。

它把 30 年前的旧设计图，配上 LLM 这台新发动机， 变成一种"你给目标，它给结果"的新生命。

软件的主体性第一次从用户手里部分转移给了机器。

看清楚发动机长什么样、车在怎么跑、路在怎么修， 比赌"哪辆车会赢"重要得多。

---

延伸阅读

• Anthropic, Building effective agents
• OpenAI, A Practical Guide to Building Agents
• Google, Agents White Paper
• 姚顺雨等人（Shunyu Yao et al.），ReAct: Synergizing Reasoning and Acting in Language Models，2022
• Model Context Protocol (MCP)
• Agent2Agent (A2A) Protocol

---

本章是后续所有章节的入口。如果你已经懂了这一篇，可以直接进入 核心循环模式 开始啃细节。