0-0 从 Turn-Based Agent 到 Real-Time Interactive Agent 和 2-2 实时交互系统架构与协议 分别讨论了实时交互智能体的理想形态,以及以 Event、Action、Task 和 State 为核心的系统架构。
我们希望构建的系统能够持续接收用户输入,同时进行复杂推理、工具调用与长期任务执行。用户不必等待任务结束,就可以继续交流、查询进度或修改任务方向。
但这会引入一个核心问题:
当交互、推理和行动具有独立的执行时间线时,系统应该如何协调它们?
传统异步任务系统已经具备一系列成熟机制,包括异步调用、任务调度、消息传递、运行中更新、协作式取消、任务状态管理与失败恢复。
这些机制为实时交互系统提供了重要基础,但并不能直接解决全部问题。
例如,用户在后台任务执行期间提出新约束,系统不仅需要把消息传递给执行器,还需要确定新约束何时生效、哪些已有结果受到影响,以及如何根据最新状态继续推理和反馈。
本文从传统异步执行模型出发,分析同步与异步、并发与并行、Scheduler 与 Controller、运行中任务控制,以及事件顺序和一致性问题,进一步讨论实时交互系统所需要的 Interactive Scheduling。
本文主要研究 Runtime 层面的执行与协调机制,而非模型内部的全双工训练架构,也不预设必须使用双脑实现。
1. 为什么实时交互系统需要异步执行?
Section titled “1. 为什么实时交互系统需要异步执行?”1.1 两种独立的时间尺度
Section titled “1.1 两种独立的时间尺度”实时交互系统至少存在两类具有不同时间要求的活动。
第一类是即时交互,例如用户说话、模型回应、插话处理、短问题回答。
第二类是长期工作,例如深度推理、运行代码、操作浏览器、搜索资料以及等待外部工具执行完成。
它们具有不同的执行时长与响应要求。
| 活动 | 主要目标 | 时间特征 |
|---|---|---|
| 语音输入与输出 | 连续、自然、低延迟 | 高频、持续 |
| 用户即时问题 | 及时回应 | 通常为短时操作 |
| 复杂推理 | 形成可靠结论 | 可能需要较长计算 |
| 工具调用 | 改变或观察外部环境 | 时长不确定 |
| 后台任务 | 持续完成用户目标 | 可能跨越多个交互轮次 |
| 运行中控制 | 及时影响已有工作 | 对生效时间敏感 |
如果将所有活动放在一条必须依次完成的执行链中,长时间任务就可能影响交互体验。
例如:
用户提出任务 ↓模型开始推理 ↓等待工具完成 ↓继续推理 ↓返回结果 ↓处理新的用户输入这个结构适合离散的任务执行,但不适合持续交互。
理想情况下:
用户交互不应该被后台任务的完成时间所约束。
1.2 异步带来的执行解耦
Section titled “1.2 异步带来的执行解耦”异步执行允许系统发起一个操作后,不必立即等待它完成。
时间 ──────────────────────────────────→
交互: 请求 A ─→ 对话 ─→ 输入 B ─→ 反馈 │ │ ↑ ▼ ▼ │执行: 执行 A ───────────────→ 结果 A在任务 A 尚未完成时,系统已经能够处理用户的后续输入 B。
但异步只解决了不必等待的问题。
它不会自动解决:
- B 是否应该修改 A。
- A 的结果是否仍然有效。
- B 是否需要立即中断 A。
- A 的结果应该什么时候告知用户。
- 多个事件同时到达时应该先处理什么。
这些需要调度、状态管理和任务控制机制共同处理。
2. 先区分几个核心概念
Section titled “2. 先区分几个核心概念”讨论 Runtime 之前,需要明确执行、调用、等待和调度分别描述什么。
2.1 串行、并发与并行
Section titled “2.1 串行、并发与并行”这三个概念主要描述多个任务的执行关系。
串行(Serial Execution)
一个任务完成后再执行另一个任务。
并发(Concurrency)
多个任务在同一时间段内推进,可以通过时间片或协作式切换实现,不要求同时占用多个 CPU 核心。
并行(Parallelism)
多个任务在物理时间上同时执行,例如运行于不同 CPU 核心。
串行执行:任务 A 完成 → 任务 B 开始单核并发:A 的步骤 → B 的步骤 → A 的步骤 → B 的步骤多核并行:核心 1 执行 A 核心 2 同时执行 B对于实时交互系统,主要要求是不同活动能够并发推进。
它们是否需要物理并行,取决于计算需求和部署环境。
2.2 同步与异步
Section titled “2.2 同步与异步”同步与异步描述操作的调用和结果交付方式。
同步调用通常要求调用方在当前操作流程中获得结果,再推进依赖结果的后续工作。
异步调用允许调用方发起操作后继续处理其他工作,结果在未来通过事件、回调或 Future 返回。
因此:
同步/异步不是并发/并行的另一种说法。
一个单线程事件循环可以实现大量异步 I/O,也可以在一个多核系统上执行同步阻塞调用。
2.3 阻塞与非阻塞
Section titled “2.3 阻塞与非阻塞”阻塞与非阻塞描述调用时的等待行为。
- Blocking:调用线程可能挂起,直到满足返回条件。
- Non-blocking:操作暂时无法完成时,调用能够及时返回。
需要注意,await 可以挂起当前协程,同时允许事件循环线程执行其他协程。
它不等于阻塞整个操作系统线程。
四种常见组合如下:
| 组合 | 行为 |
|---|---|
| 同步阻塞 | 调用线程等待操作结果 |
| 同步非阻塞 | 调用及时返回,应用主动检查状态 |
| 异步非阻塞 | 发起操作后继续工作,随后通过事件或 Future 获得结果 |
| 异步操作 + 阻塞等待 | 任务异步执行,但调用方随后阻塞等待其结果 |
最后一种尤其说明:
使用异步 API,不代表整个程序一定不会阻塞。
2.4 调度与任务同步
Section titled “2.4 调度与任务同步”调度(Scheduling)决定任务何时获得执行机会,以及如何分配资源。
任务同步(Task Synchronization)则协调任务之间的依赖和共享状态。
例如:
Task A:修改代码 │ ▼Task B:运行测试即使 A、B 都通过异步 API 创建,B 仍可能必须等待 A 完成相关修改。
这种等待关系不是同步调用的必然结果,而是任务依赖所要求的协调。
3. 传统异步任务系统的基本架构
Section titled “3. 传统异步任务系统的基本架构”传统异步任务系统通常可以抽象为四类职责:
- Client:提交任务和控制请求。
- Controller:管理任务状态和控制操作。
- Scheduler:安排任务执行。
- Executor / Worker:真正执行任务。
这是一种逻辑划分。
并不是所有异步系统都有独立的 Controller、Scheduler 和 Worker 进程。
例如,Python asyncio 通过事件循环和 Task 对象提供异步执行与协作式取消,并没有一个独立的任务控制服务。
而 Temporal 这样的工作流引擎则通过 Server、Workflow 和 Worker 等组件提供更完整的持久化执行能力。11 Temporal Technologies. Workflow Execution. 持久化执行、事件历史与恢复。
3.1 Controller 负责什么?
Section titled “3.1 Controller 负责什么?”Controller 管理任务控制面。
典型职责包括:
- 创建和定位任务。
- 检查任务当前状态。
- 接收取消或更新请求。
- 将控制指令传递给执行器。
- 跟踪控制结果。
- 对外提供任务状态查询。
Controller 不一定能够直接改变正在执行的代码。
最终能否取消或更新,取决于 Executor 是否支持相应控制语义。
3.2 Scheduler 负责什么?
Section titled “3.2 Scheduler 负责什么?”Scheduler 主要负责执行安排。
例如:
- 哪些任务可以开始?
- 哪些任务需要排队?
- 哪些任务优先级更高?
- 哪些任务必须等待依赖?
- 当前资源是否允许启动更多任务?
它不一定需要理解任务的业务语义。
例如,传统 Scheduler 可以根据优先级或资源预算安排任务,但通常不会理解“用户现在更关心训练性能,而不是数据库优化”。
这种语义需要由上层应用或模型提供。
3.3 Executor 负责什么?
Section titled “3.3 Executor 负责什么?”Executor 真正执行工作。
它可能是一个协程、线程、进程、远程 Worker 或完整的 Agent Runtime。
对于长期任务,Executor 还可能需要处理:
- 取消信号。
- 配置更新。
- 超时。
- 进度汇报。
- Checkpoint。
- 错误与清理。
这里的核心区别是:
Controller 发出控制请求,Executor 决定如何安全地执行相应控制。
4. 异步任务的生命周期与控制能力
Section titled “4. 异步任务的生命周期与控制能力”传统异步系统通常支持一组任务控制操作,但不同框架的实现能力存在差异。
| 类别 | 典型操作 | 目的 |
|---|---|---|
| 创建与启动 | Create、Submit、Start | 发起新工作 |
| 调度 | Enqueue、Delay、Prioritize | 安排执行时机 |
| 观察 | Query、Status、Progress | 获得执行状态 |
| 运行中控制 | Update、Signal、Pause、Resume | 调整正在进行的工作 |
| 终止 | Cancel、Terminate | 停止执行 |
| 恢复 | Retry、Restart、Recover | 处理失败或中断 |
Agent 里的异步工具调用也是这样一个任务句柄:事件是 call、若干 progress、result;控制是 cancel,可选 steer。Harness 收到 tool_use 后马上返回一个占位 tool_result(“已启动,task_id”),真正的结果之后作为一条新消息到达。
这里不能假定所有框架都提供通用的 Pause、Resume 或 Update。
例如,一次性后台任务可能没有任何运行中更新能力;而工作流系统通常可以通过 Signal 或 Update 处理外部控制。
4.1 简化任务状态机
Section titled “4.1 简化任务状态机”stateDiagram-v2 [*] --> Created Created --> Queued: Submit Queued --> Running: Dispatch Running --> Waiting: Wait Waiting --> Running: Resume Running --> Cancelling: Cancel request Cancelling --> Cancelled: Stop confirmed Running --> Completed: Success Running --> Failed: Error Failed --> Queued: Retry Queued --> Cancelled: Cancel before start Completed --> [*] Cancelled --> [*]这是概念状态机。
实际系统可能还具有暂停中、重试中、超时、补偿中等状态。
4.2 控制请求和状态变化必须区分
Section titled “4.2 控制请求和状态变化必须区分”例如:
CancelRequested ↓CancelAccepted ↓Cancelling ↓Cancelled各个阶段的含义并不相同。
CancelRequested 只说明有一项取消意图。
CancelAccepted 说明控制系统或执行器接受了请求。
Cancelled 才表示任务满足定义好的取消完成条件。
取消也不等于没有结果事件。被取消的 tool_use 仍然要补一个 stub tool_result,因为 API 要求每个 tool_use 都有对应的结果。
模型层有同样的区分:交互流说“好的,张江”只是接受,推理流开始按张江计算才算生效,要往上发一条 applied 确认,见 2-1 第 4.1 节。
对于运行中的外部操作,取消还可能产生部分副作用。
因此,任务已取消并不自动表示此前所有操作已经回滚。
这一点对于实时交互系统尤其重要,因为系统不能在用户说“停”后,未经确认便断言后台工作已经停止。
5. 已经执行的任务如何进行更新?
Section titled “5. 已经执行的任务如何进行更新?”这是传统异步系统中最值得借鉴的部分。
假设任务 A 已经启动,执行到一半时,用户发现原有要求不合适。
系统通常有四种处理方式。
| 方式 | 机制 | 适用场景 |
|---|---|---|
| Cooperative Update | 任务主动检查新的参数或控制状态 | 可以安全地运行中调整 |
| Signal / Message | 通过控制通道发送更新消息 | 长时间运行的工作流 |
| Cancel & Restart | 取消旧任务,使用新参数重新执行 | 无法安全原地修改 |
| Terminate | 直接终止执行实体 | 紧急终止或最后手段 |
5.1 Cooperative Control:协作式控制
Section titled “5.1 Cooperative Control:协作式控制”协作式控制要求任务在执行过程中主动检查控制状态。
例如:
async def worker(control): while not control.finished: if control.cancel_requested: await cleanup() return
config = control.current_config await execute_next_step(config)这种方式能够在步骤边界应用新配置。
它的关键特征是:控制生效的时间由执行器的安全检查点决定,而不是由外部控制消息到达的时间直接决定。
例如,任务正在写入数据库时,可能不能立即更改数据结构,而需要完成当前事务或执行回滚。
5.2 Signal / Update:消息驱动的任务控制
Section titled “5.2 Signal / Update:消息驱动的任务控制”另一种方式是让运行中的任务能够接收控制消息。
例如:
在这类架构中,控制消息和执行逻辑可以具有相对独立的生命周期。
例如,Task 正在等待一个工具结果时,仍然可以接收并记录新的约束。
但如果执行器没有能力在当前步骤中处理新状态,实际修改仍可能需要等待下一次执行机会。
5.3 Temporal 的设计经验
Section titled “5.3 Temporal 的设计经验”Temporal 为运行中的工作流提供了三类消息操作。
| 操作 | 语义 | 典型用途 |
|---|---|---|
| Query | 只读查询工作流状态 | 查询进度 |
| Signal | 异步发送消息,由工作流处理 | 修改要求、发送外部事件 |
| Update | 可验证、可等待接受或完成结果的状态更新 | 修改参数并确认结果 |
例如,工作流正在处理任务 A,外部发送一条新的约束。
Workflow Running │ ├── Execute Step 1 │ ◄── Signal(Update Constraint) │ ├── Update Workflow State │ └── Execute Step 2 with New ConstraintTemporal 将工作流消息与事件历史结合,可以在 Worker 重放工作流时恢复相关逻辑状态。22 Temporal Technologies. Workflow Message Passing — 运行中任务的 Signal、Update 和 Query 机制。
需要强调:更新 Workflow 状态,并不意味着已经运行的 Activity 会自动改变行为。
如果 Activity 已经使用旧参数开始执行,需要由应用决定是否取消、等待、补偿,或在后续 Activity 中应用新状态。
5.4 Cancel 与 Terminate 的区别
Section titled “5.4 Cancel 与 Terminate 的区别”传统异步系统经常区分协作式取消和强制终止。
以 Python asyncio 为例,调用 Task.cancel() 会请求向协程注入 CancelledError。取消不是对任意 CPU 指令的即时强制停止,协程仍有机会处理异常和清理。33
Python Software Foundation. Coroutines and Tasks — asyncio. 协程、异步任务、取消和任务组。
而 Celery 的普通 revoke 主要用于阻止排队任务继续启动;对于已经执行的任务,通常不会自动停止。其终止选项涉及 Worker 子进程,可能影响正在进行的操作。44
Celery Project. Workers Guide. 任务撤销、Worker 控制和执行终止。
这反映出一个通用原则:
安全取消与立即终止是不同的控制语义。
在实时交互系统中,用户可能期望系统立即响应“停止”,但实际执行可能需要安全退出时间。
因此,需要区分交互响应延迟与实际控制生效延迟。
5.5 Modify 通常是取消再重发
Section titled “5.5 Modify 通常是取消再重发”1-1 从 ReAct 到持续推理 已经比较了 ReAct 和 Async ReAct 的执行方式,这里只看行动层的结果。
传统 ReAct 常被实现为:
Reason → Act → Wait → Observe → Reason在持续交互模型中,更合理的逻辑关系是:
Modify Action 通常不是改写一个正在运行的调用。已经发出的工具调用是推理状态的一部分,修改一般就是取消,再重新发起。Cancel 和工具调用一样,必须是同一个模型的显式输出,由 Harness 执行(1-3 第 1.3 节)。
其中最重要的区别是:
模型不必等待当前外部 Action 完成后,才能处理所有其他输入。
这不是放弃 ReAct,而是把 Reason–Act–Observe 组织进一个更加开放的持续事件循环。
6. Scheduling:调度到底解决什么问题?
Section titled “6. Scheduling:调度到底解决什么问题?”前面讨论的 Controller 主要回答:
我们可以对任务执行什么控制?
Scheduling 则回答:
在当前状态与资源条件下,什么时候执行什么工作?
6.1 传统调度的主要职责
Section titled “6.1 传统调度的主要职责”传统任务 Scheduler 通常考虑以下因素:
| 调度因素 | 核心问题 |
|---|---|
| Priority | 哪个任务优先? |
| Dependency | 哪些任务需要等待? |
| Resource | 当前是否有足够资源? |
| Deadline | 是否存在截止期限? |
| Fairness | 是否需要保证任务之间的公平性? |
| Concurrency Limit | 允许多少任务同时执行? |
| Preemption | 是否需要中断当前工作? |
这些机制的目标是提高任务执行效率,并在资源限制下满足系统需求。
6.2 实时交互引入新的调度对象
Section titled “6.2 实时交互引入新的调度对象”对于 Continuous Interactive Agent,调度对象不再只有后台任务。
还包括:
- 实时交互事件。
- 模型推理工作。
- 工具调用。
- 用户控制请求。
- 后台结果事件。
- 反馈输出。
例如,系统正在执行复杂推理时,用户突然提出:
“停止修改文件。”
此时可能需要优先处理控制请求,而不是继续执行大量低优先级的后台分析。
但是,如果用户只是问:
“现在进度怎么样?”
系统可能只需读取已有状态,不需要暂停后台任务。
因此,调度决策依赖事件类型、任务状态和用户交互需求。
6.3 我建议将 Interactive Scheduling 分成四类
Section titled “6.3 我建议将 Interactive Scheduling 分成四类”| 类型 | 主要对象 | 核心问题 |
|---|---|---|
| Task Scheduling | 长期任务与行动 | 何时启动、等待、并发? |
| Intervention Scheduling | Cancel、Steer、Pause | 新指令何时生效? |
| Event Scheduling | 工具结果、进度、错误 | 哪些事件优先处理? |
| Feedback Scheduling | 用户可见的反馈 | 什么时候表达? |
表中的 Steer 指 Agent 级的运行中引导:把新输入交给正在运行的 Agent Turn,在下一次模型调用的边界进入上下文(1-2 新输入怎么进入进行中的推理 第 1.2 节);它和打断后继续的计算形态相同(1-2 第 1.3 节)。
其中,Feedback Scheduling 是实时交互系统特别值得单独研究的问题。
例如,后台任务完成后:
- Runtime 可以立即记录完成状态。
- 模型可以在下一次决策中获得这一事实。
- 用户不一定需要立即听到通知。
结果怎样到达模型,有两种方式:
- 推送(push):Harness 把完成事件推给模型。Claude Code 这样做,空闲时会自己开一轮。这要求 Harness 能在没有用户消息时开始一轮。
- 拉取(pull):模型用 session id 自己去取输出。Codex 这样做。一轮结束后没有人再去取,结果就一直停在那里。
两种方式都不给结果标注它所基于的前提版本。
因此:
事件处理完成、模型理解事件、用户接收到反馈,可能发生在三个不同的时间点。
6.4 Scheduler 不应替代模型的语义决策
Section titled “6.4 Scheduler 不应替代模型的语义决策”假设用户说:
“刚才那个任务先停一下。”
系统首先需要理解:
- 用户是想停止讲话,还是暂停后台工作?
- “刚才那个”具体指哪个 Task?
- “停一下”是 Pause 还是 Cancel?
这些是语义问题,不能仅靠 CPU 调度算法或任务优先级队列解决。
更合理的职责划分是:
模型或语义层提出操作意图,Runtime 验证执行对象,Scheduler 决定执行安排,Executor 完成实际控制。
它们不必是四个独立服务,但逻辑职责需要明确。
7. 并发事件如何影响正在进行的推理?
Section titled “7. 并发事件如何影响正在进行的推理?”这是 2-2 实时交互系统架构与协议 的时间与因果一节已经提出、也是实时交互系统最核心的问题之一。
它的根源是 1-2 第 1 节说的“计算期间状态在变”:一次计算读的是开始时的前提快照,前提在它结束前被改了,结果就可能不再成立。
工具结果和推理是这个问题在两层的表现。1-2 讨论模型层的推理,本节只讨论 Harness / Runtime 层的工具结果和任务。
假设有两个事件:
- 事件 A:用户要求调研在上海租房住哪个区合适,公司在陆家嘴。
- 事件 B:用户修正“刚才说错了,公司在张江”。
事件 A 已经触发了一项耗时的通勤计算,事件 B 在计算结果返回前到达。
此时有两条并发推进的时间线:
交互流与推理流的并发事件时序
7.1 事件 B 不会改变事件 A 的历史
Section titled “7.1 事件 B 不会改变事件 A 的历史”假设工具 A 按陆家嘴算完通勤时间,在用户改口之后才返回,结果是住在陆家嘴附近通勤最短。
事件 B 不会自动改变此前已经发生的计算结果。
但它可以改变系统如何使用这一结果。
例如:
旧结论:
住在陆家嘴附近通勤最短,下一步细看陆家嘴附近的小区。
新结论:
通勤时间是按陆家嘴算的;公司在张江,通勤这条不成立,租金的结论不受影响,选小区的计划需要按张江重做。
这说明:
事件到达顺序与决策依赖关系需要分开理解。
7.2 对结果的解释应该依赖什么状态?
Section titled “7.2 对结果的解释应该依赖什么状态?”一个自然的设计是使用任务状态版本。
结果基于旧前提时,有四种处理方式:
- 结果到达时检查版本:结果带上它所基于的版本,与当前版本不同就标为过期。
- 前提一变就取消:取消基于旧版本的工具,按新版本重发。
- 任务结束前冻结前提:新约束排队,等当前任务结束再生效。
- 把结果交给模型判断:不做标记,由模型读结果和新约束,自己决定还能用多少。
上图是 (1) 加 (4):Result A 带着 v1 的来源,和 v2 一起交给模型重新评估。现有的 Harness 只做 (4)。
但并不是所有结果都必须被丢弃或重新计算。
需要区分三种情况:
| 结果类型 | 处理方式 |
|---|---|
| 纯观察结果 | 通常可以保留,并基于最新状态重新解释 |
| 依赖旧约束的计划 | 需要重新验证或重新规划 |
| 已经执行的外部副作用 | 必须检查实际影响,必要时补偿 |
例如,各区的租金数据与公司位置无关,仍然有效。
但“按陆家嘴选小区”的计划已经失效。
如果已经按陆家嘴附近预约了看房,则不仅需要重新推理,还需要实际取消这些预约。
7.3 最新状态也不意味着无条件覆盖
Section titled “7.3 最新状态也不意味着无条件覆盖”另一个风险是:后到事件可能与此前事件无关。
例如用户在租房调研期间问:
“今天星期几?”
这是一个新的交互事件,但不应该自动改变租房调研任务的目标。
因此,系统首先需要建立正确的事件与任务关联。
只有确认事件 B 与任务 A 相关,才能将其应用于任务状态。
在更严格的系统中,还可以使用任务版本、预期状态和因果关系进行验证。
8. 一致性:异步系统为什么需要显式状态管理?
Section titled “8. 一致性:异步系统为什么需要显式状态管理?”当多个活动独立推进时,系统不能再假设所有参与者总是观察到同一个最新状态。
例如:
- 推理流正在使用 Task State v1。
- 交互流已经接受了用户的新约束。
- Runtime 将任务状态更新为 v2。
- 某个旧工具调用仍然基于 v1 执行。
- 工具结果随后返回。
这时,系统中可能同时存在不同版本的认知和执行状态。
8.1 需要区分三类状态
Section titled “8.1 需要区分三类状态”2-2 实时交互系统架构与协议 把状态分成 Interaction State、Task State 和 Execution State,权威来源分别是交互模型、Task Runtime 和执行环境。从一致性角度看,三类状态的要求不同。
Interaction State 可以包含不确定的语义判断。
Task State 则需要更明确的状态转换和版本管理。
Execution State 必须以实际执行结果为依据。
8.2 乐观并发控制
Section titled “8.2 乐观并发控制”一种常见方法是使用版本号。
例如:
{ "task_id": "task_42", "command": "update", "expected_revision": 7, "changes": { "office": "Zhangjiang" }}Runtime 检查当前任务版本。
如果仍然是 v7,则可以接受更新,生成 v8。
如果已经变成 v9,则需要重新验证请求是否仍然适用,而不是简单覆盖。
这种机制类似数据库中的 Optimistic Concurrency Control。
它只处理写冲突:两条 Update 命令基于同一版本修改任务。另一类问题是读到过期快照:工具或推理基于 v1 算完,结果回来时任务已是 v2。expected_revision 管不到它,需要结果自己带上版本,即 7.2 节的方式 (1)。
但版本一致不等于语义正确。
即使更新成功写入 Task State,仍需要 Executor 决定如何处理已经开始的行动。
8.3 控制请求需要幂等性
Section titled “8.3 控制请求需要幂等性”在异步系统中,网络超时可能导致调用方重复发送同一个请求。
例如:
Cancel Task A ↓请求已被执行器接收 ↓响应丢失 ↓调用方重新发送 Cancel如果每次请求都触发独立且不可重复的副作用,就可能产生错误。
因此,重要控制请求应该具备稳定的 command_id 或 idempotency_key。
Runtime 可以根据该标识识别重复请求,并返回已有执行状态。
需要注意,幂等性并不意味着所有外部工具天然支持精确一次执行;对于不可事务化的外部副作用,还需要去重、状态核对或补偿机制。
9. 失败、恢复与执行可靠性
Section titled “9. 失败、恢复与执行可靠性”持续交互系统中的任务可能执行很长时间,因此必须考虑各种中断情况。
例如:
- 用户关闭实时会话。
- 网络连接断开。
- 模型服务暂时不可用。
- Worker 进程崩溃。
- 外部工具超时。
- Runtime 在控制请求处理中重启。
9.1 会话失败不应自动意味着任务失败
Section titled “9.1 会话失败不应自动意味着任务失败”Session 和 Task 是不同的生命周期。
Interaction Session A ────────────X 连接中断
Task A ───────────────────────继续执行────完成
Interaction Session B ─────重新连接────如果产品允许后台持续执行,Task 应该能够独立于一次实时连接存续。
但这需要明确的授权、资源配额与任务持久化策略。
9.2 Retry 与 Resume 不同
Section titled “9.2 Retry 与 Resume 不同”Retry 通常意味着重新尝试一次失败的操作。
Resume 则意味着从已有执行状态继续推进。
例如:
- API 请求失败后再次调用,属于 Retry。
- 从已经保存的工作流状态继续运行,属于 Resume。
- 重新执行整个任务,属于 Restart。
这几个操作可能产生不同的副作用,不能混为一谈。
9.3 Event History 与 Checkpoint
Section titled “9.3 Event History 与 Checkpoint”为了实现可靠恢复,可以使用事件历史记录任务执行过程。
例如:
TaskCreatedActionStartedToolResultReceivedTaskUpdateAcceptedTaskUpdateAppliedActionCompletedTaskUpdateAccepted 与 TaskUpdateApplied 分开记,和 2-1 第 4.1 节模型层的接受与 applied 确认是同一个区分。
同时,周期性保存 Task Snapshot 或 Checkpoint,减少恢复成本。
但需要区分:
- 系统状态恢复:恢复 Task 的目标、版本、执行进度。
- 模型认知恢复:重新构造模型所需的上下文。
- 外部执行恢复:确认外部工具实际执行到了哪里。
其中外部执行恢复通常最困难。
例如,一个文件写入操作可能已经完成,但执行结果事件在网络中丢失。
系统需要先检查文件的真实状态,而不是立即重复写入。
10. 实时性:调度目标不只是吞吐量
Section titled “10. 实时性:调度目标不只是吞吐量”传统异步系统经常以吞吐量、任务完成时间与资源利用率为主要目标。
但 Real-Time Interactive Agent 必须加入交互响应性和控制延迟。
10.1 两类不同的实时要求
Section titled “10.1 两类不同的实时要求”Interaction Real-Time
关注语音输入、输出和打断。
例如:
- 首次响应延迟。
- 打断检测与停止播放延迟。
- 流式语音的连续性。
- 交互事件处理延迟。
Task Responsiveness
关注正在执行的工作能否被及时观察和干预。
例如:
- Steer 被接受的延迟。
- Cancel 真正生效的延迟。
- 后台进度到达的延迟。
- 任务状态更新的延迟。
二者可能具有不同的时间预算。
不能因为语音模型快速回答“好的,已经停止”,就认为控制操作已经满足任务响应要求。
10.2 端到端控制延迟
Section titled “10.2 端到端控制延迟”一个控制请求的生效时间,可以概念性地分解为:
其中:
- :理解控制意图的时间。
- :定位任务并路由指令的时间。
- :等待执行机会的时间。
- :执行器真正应用控制的时间。
这是用于分析的延迟分解,并不是严格的实时性证明公式。实际系统还可能出现并行阶段、重试与额外确认。
它说明一个重要事实:
降低模型语音响应延迟,不一定能够降低任务实际停止的延迟。
10.3 需要防止后台工作占用实时交互资源
Section titled “10.3 需要防止后台工作占用实时交互资源”例如,后台深度推理持续占满 GPU,可能导致用户的即时语音回应延迟显著上升。
交互与推理之间的资源争用在这里讨论。1-3 第 3 节假设两者的计算资源分开分配,不讨论争用。
因此,Runtime 可能需要支持:
- 交互工作优先级。
- 后台并发限制。
- 计算预算分配。
- 可抢占或可协作暂停的推理。
- 不同类型事件的独立队列。
- 控制消息优先于普通后台进度。
这里与持续推理(1-0)直接相关。
模型是否能够及时处理新输入,是模型能力与推理调度共同决定的。
11. 推理 Runtime 将承担什么新职责?
Section titled “11. 推理 Runtime 将承担什么新职责?”对于传统 LLM,Inference Runtime 主要负责执行模型推理,例如请求调度、Batching 和 KV Cache 管理。
当模型需要同时处理实时交互和深度推理时,Runtime 面临新的要求。
11.1 不同计算活动具有不同时间预算
Section titled “11.1 不同计算活动具有不同时间预算”交互推理需要低延迟。
深度推理可能需要较长的计算时间。
因此,推理引擎可能需要:
- 为交互计算保留响应机会。
- 暂停或降低后台推理的执行优先级。
- 管理多个逻辑推理上下文。
- 在新的用户输入到达后调整推理执行。
- 减少不必要的重复 Prefill 和 Decode。
但 Runtime 只能决定计算如何安排,不能单独判断一个新约束在语义上是否使某项旧结论失效。
因此需要区分:
Model Capability:理解新信息如何影响当前问题。
Inference Runtime:执行计算的暂停、恢复、调度或重启。
两者需要协同。
11.2 统一模型不等于单一执行流
Section titled “11.2 统一模型不等于单一执行流”未来即使采用一个统一模型,也可能同时拥有:
- 低延迟交互上下文。
- 长时间深度推理上下文。
- 等待中的工具调用。
- 外部事件反馈。
这些活动可以共享模型参数,但不需要共享一个严格串行、不可抢占的推理过程。
因此,持续推理可以通过不同架构实现,包括统一模型的多个逻辑推理流、分时推理或其他持续状态机制。
不能简单认为“一个模型”就天然能够一边交互一边推理。
这个判断贯穿整个系列:Unified Intelligence 不等于 Serial Execution。
12. 从传统异步系统到 Interactive Runtime
Section titled “12. 从传统异步系统到 Interactive Runtime”经过前面的分析,我们可以明确两者的关系。
传统异步系统已经能够实现:
- 独立执行。
- 任务排队。
- 运行中控制。
- 状态查询。
- 失败恢复。
- 事件记录。
但持续交互系统还需要处理自然语言输入与后台工作之间的关系。
12.1 核心差异
Section titled “12.1 核心差异”| 维度 | 传统异步任务系统 | Interactive Runtime |
|---|---|---|
| 输入 | API 请求、结构化命令 | 持续自然语言与多模态事件 |
| 执行 | 后台任务独立推进 | 交互、推理、行动同时推进 |
| 控制 | 预定义 Cancel、Update 等 | 根据交互意图选择控制操作 |
| 状态 | Task 与 Execution 状态 | 还需要 Conversation Focus |
| 调度 | 优先级、依赖、资源 | 还需要干预和反馈调度 |
| 反馈 | 通知、查询、结果 | 与当前对话自然融合 |
因此,Interactive Runtime 不是完全不同的计算系统。
更合理的理解是:
它建立在传统异步任务机制之上,增加了面向持续交互的语义关联、实时干预和反馈协调能力。
12.2 我建议的核心协调流程
Section titled “12.2 我建议的核心协调流程”这并不意味着所有输入都必须经过完整流程。
例如,用户简单问候不需要创建 Task;普通工具进度事件可能只需要更新状态,而不立即反馈。
此外,该流程也不应该被实现为一条阻塞式流水线。
不同任务和事件可以独立推进,只有存在明确因果依赖时才需要等待。
12.3 不应重复实现已有执行器的能力
Section titled “12.3 不应重复实现已有执行器的能力”这条原则对实际工程非常重要。
如果底层 Agent Runtime 已经具备:
- Thread / Task 管理。
- 工具执行。
- 内部调度。
- 中断与 Steering。
- 事件流和状态恢复。
上层 Interactive Runtime 就不需要重新实现其内部 Agent 控制机制。
它更应该关注:
持续交互如何可靠地映射到已有执行实体,以及后台状态如何重新进入用户交互。
因此,Interactive Runtime 的具体大小和复杂度,取决于底层模型和 Agent Runtime 已经原生提供了多少能力。
13. 一个具体场景:连续 Steering 与迟到结果
Section titled “13. 一个具体场景:连续 Steering 与迟到结果”为了把前面的机制串联起来,我们考虑一个完整场景。
用户要求:
帮我调研一下在上海租房住哪个区合适,公司在陆家嘴,必要时预约看房。
系统创建 Task A,开始调研。
随后用户修正:
刚才说错了,公司在张江。
在修正被接受前,旧执行流已经启动了部分工具工作。
13.1 事件时间线
Section titled “13.1 事件时间线”| 时间 | 事件 | 可能的系统处理 |
|---|---|---|
| T1 | 创建 Task A | 记录目标与版本 v1 |
| T2 | 开始计算通勤时间 | Action A 基于 v1 执行 |
| T3 | 用户修正公司位置 | 解析为 Task Update |
| T4 | 更新被接受 | Task State 变为 v2;若工具 A 仍在运行,可取消并按 v2 重发 |
| T5 | 工具 A 返回结果 | (建议机制)标记结果产生于 v1;现有系统不打标,直接交给模型判断 |
| T6 | 模型重新评估 | 结合 v2 解释工具结果 |
| T7 | 更新后续计划 | 按张江重做选小区的计划 |
| T8 | 向用户反馈 | 说明最新状态和后续方案 |
这里可能出现两个竞争情况。
情况 A:旧结果只是分析数据。
该结果可以继续使用,但后续规划必须以 v2 的张江为前提。
情况 B:旧行动已经按陆家嘴附近预约了看房。
此时不仅需要重新评估结果,还要检查已经产生的副作用:这些看房预约需要取消。
必要时执行补偿或修正,并向用户准确说明实际状态。
13.2 这个场景体现了什么?
Section titled “13.2 这个场景体现了什么?”它同时涉及多个系统机制:
- Async:工具 A 在后台独立执行。
- Scheduling:新控制请求需要及时处理。
- Communication:更新请求与工具结果异步到达。
- State:任务状态存在 v1、v2。
- Lifecycle:任务在运行中发生修改。
- Interaction:最终结果必须依据最新用户要求表达。
因此,这个问题并不能只靠一个 Scheduler 解决。
Scheduling 只是整个持续控制循环中的一个决策环节。
真正让系统可靠工作的,是执行、通信、状态和控制机制共同建立的明确语义。
14. 设计取舍与开放问题
Section titled “14. 设计取舍与开放问题”尽管传统异步系统为实时交互提供了成熟基础,但仍有一些需要进一步研究的问题。
14.1 所有事件都应该立即进入模型吗?
Section titled “14.1 所有事件都应该立即进入模型吗?”不一定。
大量工具进度、音频片段和状态事件可能造成模型上下文膨胀。
系统需要决定哪些事件进入模型、哪些只更新状态、哪些可以压缩或合并。
14.2 更新任务时是否应该抢占推理?
Section titled “14.2 更新任务时是否应该抢占推理?”如果新约束非常重要,例如禁止修改文件,可能需要及时阻止相关操作。
但如果只是补充一个低优先级研究方向,系统可能允许当前步骤完成后再处理。
这涉及语义重要性、资源成本和安全执行边界。
14.3 是否需要独立的 Task Controller?
Section titled “14.3 是否需要独立的 Task Controller?”逻辑上的控制职责始终存在,但不一定需要独立服务。
如果底层模型和 Runtime 已经提供可靠的 Task API,上层可能只需要简单的任务映射和事件协调。
14.4 模型能否直接承担 Scheduling?
Section titled “14.4 模型能否直接承担 Scheduling?”模型可以参与判断任务紧迫性、用户意图和交互反馈时机。
但执行资源配额、权限校验、状态版本和控制确认等机制,更适合由确定性的 Runtime 维护。
这意味着未来可能形成一种 Model Policy + Runtime Enforcement 的联合决策模式。
14.5 当模型足够强大时,异步机制是否仍然必要?
Section titled “14.5 当模型足够强大时,异步机制是否仍然必要?”我认为仍然必要。
即使未来只需要一个统一 Full-Duplex Model,它也无法让真实世界的外部工具操作瞬间完成。
网络、文件系统、浏览器、进程和其他外部环境始终具有独立的执行时间。
因此,异步行动、事件回传和状态管理仍然具有系统层面的必要性。
单模型能够减少智能能力的分工,但不会消除外部世界的异步性。
15. 总结
Section titled “15. 总结”实时交互系统需要让用户交互、复杂推理和外部行动在不同时间尺度上持续推进。
传统异步任务系统已经为此提供了重要基础,包括异步调用、并发执行、任务调度、运行中控制、状态管理和失败恢复。
但这些机制本身并不理解自然语言交互,也不会自动判断一个后到事件是否应该改变已有任务。
通过本文分析,可以得到六个主要结论。
第一,异步执行是持续交互的重要基础。
它使长期工作不必占用前台交互的整个生命周期。
第二,异步与并行不是同一个概念。
系统可以通过并发和事件驱动处理多个未完成操作,而不要求每项活动都在不同核心上运行。
第三,Task Control 与 Scheduling 应该明确区分。
Task Control 定义可以对运行中任务执行哪些操作;Scheduling 决定何时处理这些任务与控制请求。
第四,运行中控制需要执行器协作。
Cancel、Update 和 Pause 不能被理解为无条件即时生效。系统必须区分请求、接受、应用和最终执行状态。
第五,后到事件可以改变先前结果的后续处理,但不会自动改变已经发生的事实。
因此,实时交互系统需要显式任务状态、版本管理、因果关联和副作用处理机制。
第六,Interactive Runtime 应当复用传统异步系统的基础能力,并增加持续交互所需要的语义关联与协调机制。
最终,我们可以将其概括为:
Asynchronous Execution 提供独立推进能力,Task Control 提供运行中干预能力,Scheduling 负责执行安排,而 Interactive Loop 将这些机制组织成一个持续感知、决策、行动和反馈的智能闭环。
对于未来的统一全双工智能体,Runtime 不应该取代模型的认知能力,模型也不应该取代 Runtime 对执行事实、资源和权限的可靠管理。
两者通过明确的事件、行动与状态协议协同工作,才有可能支撑真正的 Continuous Interactive Agent。
实时交互背景阅读:GPT-Live55 OpenAI. Getting Started with GPT-Live — 实时模型和会话通信。 66 OpenAI. Delegation and Tools in GPT-Live — Client Delegation、后台结果注入与任务状态协调。 与 Interaction Models。77 Thinking Machines Lab. Interaction Models — 持续感知、实时交互与异步后台协作。
-
Temporal Technologies. Workflow Execution. 持久化执行、事件历史与恢复。 ↩
-
Temporal Technologies. Workflow Message Passing — 运行中任务的 Signal、Update 和 Query 机制。 ↩
-
Python Software Foundation. Coroutines and Tasks — asyncio. 协程、异步任务、取消和任务组。 ↩
-
Celery Project. Workers Guide. 任务撤销、Worker 控制和执行终止。 ↩
-
OpenAI. Getting Started with GPT-Live — 实时模型和会话通信。 ↩
-
OpenAI. Delegation and Tools in GPT-Live — Client Delegation、后台结果注入与任务状态协调。 ↩
-
Thinking Machines Lab. Interaction Models — 持续感知、实时交互与异步后台协作。 ↩