从 Claude Code 到 Codex：拆解 Agent Runtime 五层架构的新技术演进

很多人以为，2025~2026 年 Agent 的进步来自模型。

但如果你真正去拆 Claude Code、Codex、Deep Agent、AutoGen、OpenHands 这类系统，会发现：

真正拉开差距的，不是模型，而是 Agent Runtime。

过去大家做 Agent，大多数还是：

text 复制代码

用户输入 → LLM → tool call → 返回

而现在，真正强大的 Agent 已经变成：

text 复制代码

任务 → 规划 → 执行 → 观察 → 调整 → 循环

甚至进一步演化成：

text 复制代码

Agent Runtime
├── Agent Loop
├── Planner
├── Executor
├── State Store
└── Environment

Claude Code、Codex、Cursor、OpenHands，本质上都已经在向这个架构靠拢。

本文就从这五层出发，系统拆解 2025~2026 年 Agent Runtime 的最新技术与演进方向。

一、Agent Loop：从 while 循环，升级成真正的运行时系统

最早的 Agent Loop 很简单：

python 复制代码

while not done:
    think()
    act()
    observe()

这也是最经典的 ReAct 模式。

但问题在于：

无法处理复杂任务
容易无限循环
无法管理多个子任务
无法中断、恢复、并行

所以新一代 Agent Runtime 已经开始演进成真正的"运行时系统"。

1. 分层循环（Hierarchical Loop）

现在越来越多系统不再只有一个 Loop，而是：

text 复制代码

主循环（任务级）
  └─ 子循环（步骤级）
        └─ 工具循环（执行级）

例如在 Claude Code 中：

text 复制代码

任务：将项目改造成 MVC

主循环：完成整个重构
子循环1：重构 controller
子循环2：重构 service
工具循环：修改文件 → 运行测试 → 修复

这种设计的好处是：

支持复杂任务拆解
可以恢复中断
每层有不同目标
可以独立重试

一个典型的实现：

python 复制代码

class TaskLoop:

    def run(task):
        subtasks = planner.split(task)

        for subtask in subtasks:
            StepLoop.run(subtask)


class StepLoop:

    def run(step):
        while not step.done:
            action = planner.next_action(step)
            ToolLoop.run(action)

2. 事件驱动 Loop（Event-Driven Loop）

过去 Agent 必须"主动轮询"。

现在越来越多系统开始变成：

text 复制代码

事件触发 → Agent 被唤醒 → 执行

典型事件包括：

Git commit
测试失败
Slack 消息
用户上传文件
某个 Agent 完成

例如：

text 复制代码

Git 提交代码
↓
触发 Review Agent
↓
Review Agent 发现问题
↓
触发 Fix Agent
↓
Fix 完成后触发 Test Agent

于是整个系统开始像"操作系统中的后台服务"，而不是一个聊天机器人。

可以理解成：

text 复制代码

Agent = 长驻后台进程

3. Reflection / Critic Loop：Agent 开始会"反思"

传统 Agent 最大的问题是：

错了也不知道自己错。

所以 2025 年后，越来越多系统开始增加"反思层"。

典型流程：

text 复制代码

执行 → 自评 → 判断失败 → 重试

例如：

text 复制代码

Planner: 先运行测试
Executor: npm test 失败
Critic: 缺少依赖，没有先 npm install
Planner: 重新规划

常见模式包括：

ReAct
Reflexion
Critic Agent
Judge Model
Self-Reflection

示例代码：

python 复制代码

while not done:

    action = planner(state)

    result = executor.run(action)

    review = critic.check(result)

    if not review.success:
        state.add_feedback(review.reason)
        continue

真正的智能，不再来自"第一次猜对"，而来自：

能否在失败后修正自己。

4. Human-in-the-Loop：人开始成为 Runtime 的一部分

现在越来越多 Agent 不会直接执行高风险动作，而是先暂停。

例如：

删除数据库
执行部署
发邮件
支付
修改大量文件

运行流程：

text 复制代码

Agent 生成计划
↓
等待用户确认
↓
继续执行

例如：

python 复制代码

if action.risk_level == "high":
    wait_user_confirm(action)

这已经是 Claude Code、Codex 等系统的常见做法。

因为：

越强大的 Agent，越需要安全边界。

二、Planner：从"让模型一步步想"，升级成真正的规划系统

很多人理解的 Planner 还是：

text 复制代码

请一步一步思考

但这已经不够了。

新一代 Planner 已经变成一个真正的"任务管理器"。

1. Plan-and-Execute

最经典的升级方向。

不是边想边做，而是：

text 复制代码

先规划，再执行

例如：

text 复制代码

任务：帮我重构项目

Planner 输出：
1. 分析项目结构
2. 找出 controller / service
3. 创建新目录
4. 重构代码
5. 运行测试

Executor 再逐步执行。

代码示例：

python 复制代码

def plan(task):
    return llm(f"""
    将任务拆解为步骤：
    {task}
    """)

相比传统 ReAct，它更稳定、更可控。

2. DAG / Task Graph

当任务复杂以后，线性步骤已经不够。

现在很多系统开始把任务建模成 DAG：

text 复制代码

分析需求
├── 查看代码
├── 查看数据库
└── 查看文档
      ↓
生成方案
      ↓
修改代码

优势：

可以并行执行
可以管理依赖
可以断点恢复

例如：

python 复制代码

class TaskNode:
    id: str
    deps: list
    action: str

Codex 的多任务执行，本质上就是在跑一个 Task Graph。

3. World Model / Cognitive Map

这是 2026 年开始非常火的方向。

Planner 不再只看 prompt，而是先构建一个"世界模型"。

例如：

text 复制代码

这个项目有哪些模块？
有哪些页面？
哪些文件彼此依赖？

先建地图，再行动。

例如 Coding Agent：

text 复制代码

扫描 Repo
↓
建立模块依赖图
↓
再决定从哪里开始修改

例如 Browser Agent：

text 复制代码

先理解页面结构
再决定点哪个按钮

这会让 Agent 的行为，从"盲目试错"变成"有地图的导航"。

4. 多模型规划（Multi-LLM Planning）

很多系统开始不再只用一个模型。

而是：

text 复制代码

小模型：拆步骤
大模型：关键决策
代码模型：写代码
Review 模型：检查

例如：

text 复制代码

Planner → GPT-4o-mini
Code Generation → Claude
Review → GPT-5

你的 MCP，如果放在这一层，其实就可以做：

模型路由
fallback
成本优化
多模型协同

三、Executor：从调用工具，升级成 Agent 操作系统

过去的 Executor：

python 复制代码

call_tool(tool_name)

现在的 Executor 已经越来越像"操作系统"。

1. Tool Schema 标准化

过去工具接口乱七八糟：

python 复制代码

run(path, text)
edit(file, content)

现在越来越多系统开始统一工具描述：

json 复制代码

{
  "name": "edit_file",
  "input": {
    "path": "string",
    "content": "string"
  }
}

这样 Planner 和 Executor 可以彻底解耦。

统一 Schema 后：

text 复制代码

Planner 只负责生成动作
Executor 负责真正执行

2. Capability Layer / MCP

真正成熟的系统，不会让 Agent 直接调工具。

而是：

text 复制代码

Agent → MCP → Tool

MCP / Capability Layer 负责：

权限控制
限流
fallback
日志
重试
参数转换

例如：

python 复制代码

result = capability.invoke(
    name="edit_file",
    params={...}
)

这一步，就是让系统从"脚本拼接"变成"工业级平台"。

3. Agent 自动生成工具

这是最近非常强的新方向。

当 Agent 发现没有工具可用时：

自己生成一个。

例如：

text 复制代码

发现缺少解析 CSV 的工具
↓
自动写一个 Python 函数
↓
注册到工具系统
↓
继续执行

这会让 Agent 具备真正的"自扩展能力"。

4. Browser / Desktop / Terminal Executor

过去 Agent 只能调用 API。

现在开始越来越多 Agent 直接操作：

浏览器
Terminal
文件系统
桌面

于是：

text 复制代码

Agent 不再只是"会调接口"
而是"会操作电脑"

这也是 Claude Code、Codex、OpenHands 真正强的地方。

四、State Store：从聊天记录，升级成真正的记忆系统

过去的 state：

text 复制代码

state = 对话历史

但这种方式很快就会爆 context。

所以现在开始演进成真正的 Memory System。

1. 短期记忆（Working Memory）

只存当前任务：

text 复制代码

- 当前做到哪一步
- 哪些文件改过
- 哪些命令执行过

例如：

python 复制代码

state.current_step = "run_test"
state.modified_files = ["app.py"]

2. 长期记忆（Long-Term Memory）

长期保存：

用户偏好
历史经验
过去任务
常见错误

例如：

text 复制代码

这个 repo 每次都要先 npm install
这个用户喜欢 TypeScript

下次就不需要重新学。

3. Episodic Memory：记录"我上次怎么失败的"

人最强的地方，是会记住经历。

所以现在 Agent 也开始记录：

text 复制代码

我上次为什么失败
我上次是怎么修好的

例如：

text 复制代码

测试失败：因为没装依赖
解决方式：npm install

下一次，Agent 会直接先执行 npm install。

4. Context Decoupling

长上下文是 Agent 最大的问题。

所以现在开始把上下文拆开：

text 复制代码

Planner 看摘要
Executor 看当前步骤
Critic 看执行结果

这样可以避免：

context 爆炸
token 成本过高
模型越来越笨

五、Environment：从工具返回值，升级成真实世界

Agent 最大的进化，就是开始拥有"环境"。

过去：

text 复制代码

call_tool → 返回结果

现在：

text 复制代码

进入真实环境 → 动手 → 看反馈

1. Sandbox

Codex、Claude Code 都会给每个任务创建一个独立环境。

例如：

text 复制代码

一个临时 Repo
一个隔离容器
一个独立终端

优点：

更安全
可以随便试
不污染真实系统

2. Snapshot / Replay

Agent 在执行前保存快照：

text 复制代码

失败 → 回滚 → 再试

类似：

Git
Docker Snapshot
VM Snapshot

例如：

python 复制代码

snapshot = env.save()

try:
    run_action()
except:
    env.restore(snapshot)

3. 模拟环境（Simulation）

真正执行前，先模拟。

例如：

text 复制代码

先预测点击这个按钮会发生什么
再真正点击

特别适合：

Browser Agent
自动化部署
机器人

4. Environment Model

这是最前沿的方向。

Agent 不只是看到环境，而是会预测：

text 复制代码

如果我这样做，会发生什么？

例如：

text 复制代码

删这个文件，会不会导致测试失败？

于是 Agent 开始具备"预判能力"。

六、总结：未来 Agent 的竞争，不在模型，而在 Runtime

最后，把整个趋势总结成一句话：

text 复制代码

更强的 Loop
+ 更强的 Planner
+ 更强的 Executor
+ 更强的 Memory
+ 更真实的 Environment
= 下一代 Agent

未来 Agent 的竞争，不是谁模型参数更大，而是谁：

更会规划
更会记忆
更会与环境交互
更会失败后修正自己

而 Claude Code、Codex 的真正强大之处，也正是在这里。

它们不是"更强的模型"。

它们是：

一个会思考、会行动、会记忆、会反思、会在真实环境中不断修正自己的系统。

而这，才是下一代 Agent 真正的方向。