源码版本 rust-v0.144.6

拆开 Codex

从源码读懂一个生产级 Agent

全书只分析 openai/codex 开源仓库：既把 Codex 的真实实现讲透，也从这些实现中解释一个生产级 Agent 需要处理的模型回路、工具执行、安全治理、状态恢复、扩展协议、多 Agent 和验证体系。

开始阅读查看源码

查阅索引

动态工具声明与领域执行器的分离: Dynamic Tools 为什么把执行权交回宿主
逻辑 process_id: 命令返回以后，进程为什么还活着
宿主拥有执行权: Dynamic Tools 为什么把执行权交回宿主
account login identity: 登录身份不等于 Agent 身份
active context versus cumulative usage: 上下文快满时，Codex 到底压缩了什么
active item projection: 一条 Responses 流怎样变成下一步行动
active turn: 你按下回车后，谁接管这次任务
active-thread failover: TUI 如何把事件流还原成一个稳定界面
Agent Identity: 登录身份不等于 Agent 身份
Agent identity versus UI identity: 一个子 Agent 为什么需要独立 Thread
aggregated follow-up control: 一条 Responses 流怎样变成下一步行动
app-server 反向 server request: Dynamic Tools 为什么把执行权交回宿主
app-server client model: 同一个 codex，为什么会启动几套不同的系统
append-only rollout: 同一段对话，为什么同时存在三种状态
approvable allowlist miss: 网络访问为什么另有一条决策链
approval cache identity: 模型返回的 Shell 参数，为什么还不是一条进程
approval prompt eligibility: 审批、Permission Profile 与沙箱各自拦什么
authoritative permission profile: 审批、Permission Profile 与沙箱各自拦什么
authority-bound resource locator: 一个 Plugin 怎样变成一组可安装能力
bespoke event projection: App-server 如何把 Core 变成一套可消费协议
bounded audio, text, handoff, and output queues: 普通 Responses 与 Realtime 为什么是两套会话
bounded event store: TUI 如何把事件流还原成一个稳定界面
bounded startup-context injection: 普通 Responses 与 Realtime 为什么是两套会话
brokered nested dispatch: Code Mode 为什么仍然绕不开同一张工具表
cancellation token: 你按下回车后，谁接管这次任务
canonical AgentPath: 一个子 Agent 为什么需要独立 Thread
canonical live history: History 为什么不能直接拿去做 Prompt
capability-specific loading: 一个 Plugin 怎样变成一组可安装能力
cell-owned JavaScript runtime: Code Mode 为什么仍然绕不开同一张工具表
child-to-parent result notification: 多个 Agent 怎样通信、等待与中断
citation provenance: Memory 不是更长的 History
claim to source to observed artifact ledger: 没有证据的“跑通”不算跑通
client event observation: 同一段对话，为什么同时存在三种状态
Code Mode control tool versus nested tool: Code Mode 为什么仍然绕不开同一张工具表
Codex as MCP client: 外部 MCP Server 的工具怎样进入 Codex
committed effect record: 一份补丁怎样落盘，又怎样成为 TurnDiff
composer state ownership: TUI 如何把事件流还原成一个稳定界面
configuration precedence: Codex 启动时，哪一份配置说了算
connection-scoped initialization: App-server 如何把 Core 变成一套可消费协议
constraint source: 配置能覆盖，Requirements 不能绕过
content items 到 function_call_output: Dynamic Tools 为什么把执行权交回宿主
context update: 模型收到的指令从哪里来
context window: 模型不是一个字符串：Provider、目录与 ModelInfo
continuation condition: Codex 为什么有两层循环
continuation reason and error semantics: Hooks 为什么不是一条统一回调链
Core 的等待型适配器: Dynamic Tools 为什么把执行权交回宿主
correlation id: 不要从目录开始读 Codex
derived SQLite projection: 同一段对话，为什么同时存在三种状态
deterministic local binary task: 没有证据的“跑通”不算跑通
deterministic network policy: 网络访问为什么另有一条决策链
direct and deferred tool exposure: 外部 MCP Server 的工具怎样进入 Codex
direct result versus code mode result: Code Mode 为什么仍然绕不开同一张工具表
discovery, exposure, approval, execution boundary: 外部 MCP Server 的工具怎样进入 Codex
durable history copy versus process snapshot: Resume 与 Fork：恢复的不是同一件事
durable identity guard: Goal 为什么必须活在 Turn 之上
durable replay versus query index: 同一段对话，为什么同时存在三种状态
durable signing key: 登录身份不等于 Agent 身份
ephemeral residency: 一个子 Agent 为什么需要独立 Thread
event projection after mutation: Goal 为什么必须活在 Turn 之上
event-specific stdin and output schemas: Hooks 为什么不是一条统一回调链
exact committed delta: 一份补丁怎样落盘，又怎样成为 TurnDiff
exec policy projection: 模型返回的 Shell 参数，为什么还不是一条进程
execution envelope: 模型返回的 Shell 参数，为什么还不是一条进程
execution-scoped network attribution: 网络访问为什么另有一条决策链
executor-selected Plugin contributor path: 一个 Plugin 怎样变成一组可安装能力
experimental opt-in memory: Memory 不是更长的 History
explicit body injection: Skills 不是工具：从目录发现到渐进注入
explicit Codex handoff into realtime output: 普通 Responses 与 Realtime 为什么是两套会话
explicit goal mutation: Goal 为什么必须活在 Turn 之上
ExtensionRegistry boundary: 一个 Plugin 怎样变成一组可安装能力
extraction state versus final corpus: Memory 不是更长的 History
fallback metadata: 模型不是一个字符串：Provider、目录与 ModelInfo
field provenance: Codex 启动时，哪一份配置说了算
general approval reviewer: 网络访问为什么另有一条决策链
global consolidation ownership: Memory 不是更长的 History
handler argv and launch argv: 模型返回的 Shell 参数，为什么还不是一条进程
history resume as a new identity: Resume 与 Fork：恢复的不是同一件事
idle continuation eligibility: Goal 为什么必须活在 Turn 之上
incremental Responses request reuse: 普通 Responses 与 Realtime 为什么是两套会话
independent CodexThread: 一个子 Agent 为什么需要独立 Thread
inert plugin descriptor: 一个 Plugin 怎样变成一组可安装能力
installed package versus runtime projection: 一个 Plugin 怎样变成一组可安装能力
instruction source ledger: 模型收到的指令从哪里来
intentional tool exposure asymmetry: 模型为什么能调用工具：两张表，一个闭环
layer evidence versus cross-layer proof: 没有证据的“跑通”不算跑通
live conversation history: 同一段对话，为什么同时存在三种状态
live registry versus persisted graph: 一个子 Agent 为什么需要独立 Thread
live subtree versus persisted graph: 多个 Agent 怎样通信、等待与中断
live versus replay handling: TUI 如何把事件流还原成一个稳定界面
local exit and task terminalization: 断流、限流和 401：Codex 分别从哪里恢复
mailbox activity versus agent completion: 多个 Agent 怎样通信、等待与中断
mailbox delivery phase: Codex 为什么有两层循环
managed requirements: 配置能覆盖，Requirements 不能绕过
manifest authority: 一个 Plugin 怎样变成一组可安装能力
matcher selection and matcher aliases: Hooks 为什么不是一条统一回调链
metadata catalog context: Skills 不是工具：从目录发现到渐进注入
model catalog: 模型不是一个字符串：Provider、目录与 ModelInfo
model-visible capability: 模型为什么能调用工具：两张表，一个闭环
model-visible exec and nested apply_patch ownership: 没有证据的“跑通”不算跑通
model-visible role: 模型收到的指令从哪里来
ModelInfo: 模型不是一个字符串：Provider、目录与 ModelInfo
network policy amendment: 网络访问为什么另有一条决策链
non-terminal blocked state: Goal 为什么必须活在 Turn 之上
observation frontier and terminal response: Code Mode 为什么仍然绕不开同一张工具表
Open and Closed spawn edges: 一个子 Agent 为什么需要独立 Thread
ordinary candidate: 配置能覆盖，Requirements 不能绕过
ordinary layer: Codex 启动时，哪一份配置说了算
owner executor governor: Dynamic Tools 为什么把执行权交回宿主
ownership: 不要从目录开始读 Codex
pairing normalization: History 为什么不能直接拿去做 Prompt
parser effect versus runtime mutation: Hooks 为什么不是一条统一回调链
pending interaction filtering: TUI 如何把事件流还原成一个稳定界面
per-call approval requirement: 审批、Permission Profile 与沙箱各自拦什么
per-thread event subscription: App-server 如何把 Core 变成一套可消费协议
per-thread UI projection: TUI 如何把事件流还原成一个稳定界面
permission profile boundary: 配置能覆盖，Requirements 不能绕过
persistent and ephemeral fork: Resume 与 Fork：恢复的不是同一件事
planned change view: 一份补丁怎样落盘，又怎样成为 TurnDiff
pre-execution block versus post-execution feedback: Hooks 为什么不是一条统一回调链
preflight and runtime failure boundary: 一份补丁怎样落盘，又怎样成为 TurnDiff
process lifecycle token 与 turn cancellation: 命令返回以后，进程为什么还活着
progressive disclosure: Skills 不是工具：从目录发现到渐进注入
progressive disclosure read path: Memory 不是更长的 History
Prompt 到 wire 的边界: Prompt 怎样变成一份 Responses 请求
prompt projection: History 为什么不能直接拿去做 Prompt
provider capability upper bound: 模型不是一个字符串：Provider、目录与 ModelInfo
provider identity: 模型不是一个字符串：Provider、目录与 ModelInfo
provider terminal response: 一条 Responses 流怎样变成下一步行动
PTY 输出合流: 命令返回以后，进程为什么还活着
queue-only delivery: 多个 Agent 怎样通信、等待与中断
raw function arguments string: 模型返回的 Shell 参数，为什么还不是一条进程
raw MCP identity versus model-visible ToolInfo: 外部 MCP Server 的工具怎样进入 Codex
reactive 401 recovery: 断流、限流和 401：Codex 分别从哪里恢复
realtime V1/V2 and WebSocket/WebRTC transport choices: 普通 Responses 与 Realtime 为什么是两套会话
recorded response item: 一条 Responses 流怎样变成下一步行动
recovery ownership: 断流、限流和 401：Codex 分别从哪里恢复
RegularTask: 你按下回车后，谁接管这次任务
replacement history checkpoint: 上下文快满时，Codex 到底压缩了什么
request auth boundary: 登录身份不等于 Agent 身份
request-open retry budget: 断流、限流和 401：Codex 分别从哪里恢复
request-scoped controls: Prompt 怎样变成一份 Responses 请求
resource-scoped request ordering: App-server 如何把 Core 变成一套可消费协议
Responses Lite: Prompt 怎样变成一份 Responses 请求
ResponsesApiRequest: Prompt 怎样变成一份 Responses 请求
ResponseStream: Prompt 怎样变成一份 Responses 请求
review decision: 审批、Permission Profile 与沙箱各自拦什么
rollout identity versus trace identity: 没有证据的“跑通”不算跑通
rollout-derived memory: Memory 不是更长的 History
route before render: TUI 如何把事件流还原成一个稳定界面
running resume versus cold resume: Resume 与 Fork：恢复的不是同一件事
runtime accounting attachment: Goal 为什么必须活在 Turn 之上
runtime control flow: 不要从目录开始读 Codex
runtime enforcement boundary: 模型收到的指令从哪里来
runtime entrypoint: 同一个 codex，为什么会启动几套不同的系统
runtime projection and effective servers: 外部 MCP Server 的工具怎样进入 Codex
runtime-executable capability: 模型为什么能调用工具：两张表，一个闭环
sampling retry budget: 断流、限流和 401：Codex 分别从哪里恢复
sampling/action loop: Codex 为什么有两层循环
sandbox backend selection: 审批、Permission Profile 与沙箱各自拦什么
screenshot as terminal projection: 没有证据的“跑通”不算跑通
separate realtime conversation state machine: 普通 Responses 与 Realtime 为什么是两套会话
server-request callback loop: App-server 如何把 Core 变成一套可消费协议
session 级进程所有权: 命令返回以后，进程为什么还活着
Session owner: 你按下回车后，谁接管这次任务
session source metadata: 同一个 codex，为什么会启动几套不同的系统
session stored values: Code Mode 为什么仍然绕不开同一张工具表
session tree lineage: Resume 与 Fork：恢复的不是同一件事
session-scoped host approval: 网络访问为什么另有一条决策链
session-scoped MCP runtime snapshot: 外部 MCP Server 的工具怎样进入 Codex
session-scoped ModelClient versus turn-scoped ModelClientSession: 普通 Responses 与 Realtime 为什么是两套会话
session-sticky transport fallback: 断流、限流和 401：Codex 分别从哪里恢复
shared ToolRouter and ToolRegistry: Code Mode 为什么仍然绕不开同一张工具表
skill root discovery: Skills 不是工具：从目录发现到渐进注入
SkillMetadata versus SkillInstructions: Skills 不是工具：从目录发现到渐进注入
skipped test as missing evidence: 没有证据的“跑通”不算跑通
snapshot replay approximation: TUI 如何把事件流还原成一个稳定界面
spawn topology versus history lineage: 一个子 Agent 为什么需要独立 Thread
spec and runtime co-ownership: 模型为什么能调用工具：两张表，一个闭环
stateful protocol adapter: App-server 如何把 Core 变成一套可消费协议
sticky turn-state routing token: 普通 Responses 与 Realtime 为什么是两套会话
stream event mapping: 一条 Responses 流怎样变成下一步行动
strict trace replay: 没有证据的“跑通”不算跑通
submission id: 你按下回车后，谁接管这次任务
synchronous command discovery boundary: Hooks 为什么不是一条统一回调链
synthetic call output: History 为什么不能直接拿去做 Prompt
task owner loop: Codex 为什么有两层循环
task-scoped assertion: 登录身份不等于 Agent 身份
telemetry as observation rather than causality: 没有证据的“跑通”不算跑通
ten event names versus separate lifecycle entry points: Hooks 为什么不是一条统一回调链
terminal state: 同一个 codex，为什么会启动几套不同的系统
terminal-prefix truncation: Resume 与 Fork：恢复的不是同一件事
thread scope versus turn scope: Hooks 为什么不是一条统一回调链
thread-scoped durable objective: Goal 为什么必须活在 Turn 之上
thread-scoped outbound delivery: App-server 如何把 Core 变成一套可消费协议
ThreadSpawn source: 一个子 Agent 为什么需要独立 Thread
tool future 与 OS process 生命周期: 命令返回以后，进程为什么还活着
tool output correlation: 模型为什么能调用工具：两张表，一个闭环
ToolRegistry boundary: Skills 不是工具：从目录发现到渐进注入
transport: 同一个 codex，为什么会启动几套不同的系统
transport resource ownership: Codex 为什么有两层循环
trigger-turn delivery: 多个 Agent 怎样通信、等待与中断
turn interruption versus thread shutdown: 多个 Agent 怎样通信、等待与中断
turn-scoped net text diff: 一份补丁怎样落盘，又怎样成为 TurnDiff
typed JSON-RPC boundary: App-server 如何把 Core 变成一套可消费协议
typed runtime override: Codex 启动时，哪一份配置说了算
typed shell payload: 模型返回的 Shell 参数，为什么还不是一条进程
usage feedback metadata: Memory 不是更长的 History
user-visible turn ownership: Codex 为什么有两层循环
workspace membership: 不要从目录开始读 Codex
world-state snapshot: 模型收到的指令从哪里来 History 为什么不能直接拿去做 Prompt