以下数字为教学示例,不构成对任何真实系统或供应商的承诺。
“让 Agent 循环跑起来"很容易,难的是让它在该停的地方停。很多 Agent 的问题不是"不会做”,而是"停不下来":任务早就没有进展了,它还在继续调用工具、消耗 token、花用户的预算。反过来,有些 Agent 停得太早:一次工具返回稍慢,就被当成失败,把本可以完成的任务提前中止。
这一节把 Agent 的循环拆成一个带显式停止条件的控制循环:循环体内做什么、循环外有什么条件、条件之间如何分层。重点不是循环怎么写,而是停止条件为什么必须是运行时约束,而不是提示词里的一句话。
循环不是 while True
一个朴素的 Agent 循环可以写成:
while True:
observe() # 取当前状态
act() # 调用工具或输出
check_finished() # 问模型:完成了吗
这个写法看起来合理,实际上把终止判断交给了模型:“完成了吗"是一个由模型回答的问题,模型可能说"还没”——哪怕任务早就结束了。没有独立的、基于系统状态的停止条件,循环的边界就是模型的倾向,而模型的倾向是"继续做点事"。
控制循环的正式结构是:状态、动作、转移、停止谓词。每一步先读状态,选择一个动作,执行后状态改变,然后由运行时的停止谓词决定继续还是终止。停止谓词不应该由模型输出决定,而应该由可计算的条件决定。
四层停止条件
停止条件不是一条,而是至少四层,每一层回答一个不同的问题:
| 层 | 条件 | 回答的问题 | 失败形态 |
|---|---|---|---|
| 任务层 | 目标达成、明确失败、用户取消 | 这件事做完了吗 | 目标漂移:做了很多事但没有完成原任务 |
| 步数层 | 最大步数、最大工具调用次数 | 还能再试吗 | 死循环:步数无上限,成本线性增长 |
| 时间层 | 单步超时、总时长预算 | 还来得及吗 | 挂起:用户不知道还要等多久 |
| 资源层 | token、金额、并发配额 | 付得起吗 | 成本失控:超出预算才被发现 |
四层之间是"且"的关系:任何一层先到上限,循环都必须终止。任务层负责"该不该停",步数、时间、资源层负责"还能不能继续"。只实现任务层的 Agent,把后三层的责任都推给了模型,等于没有停止条件。
分层还要定优先级
四层条件同时超限时,以哪一层为准?这会影响终止后的语义。优先级应该反映"哪类资源先耗尽、哪类信号更可信":
- 任务层:任务完成或失败,正常退出;
- 步数层:超过最大步数,通常意味着没有进展;
- 时间层:超过时长预算,通常意味着慢到不可接受;
- 资源层:token 或金额超限,通常意味着成本失控。
优先级靠执行顺序体现:每一轮先检查任务层,再按步数、时间、资源的顺序检查。先检查的层具有更高的终止优先级。这个顺序是工程选择,不是逻辑必然,但它必须写死并在文档里声明,否则不同的实现会得出不同的终止结果。
最小实验:漏停与早停
下面的实验用脚本化的步长与成本模拟三类运行:
- runaway:永不完成的任务,会一直消耗下去;
- slow-solve:完成得较慢的任务,需要多次尝试;
- cost-bound:任务本身能完成,但成本先到上限。
每种任务分别在两种策略下运行:只靠任务层(task-only)与四层全开(full)。所有参数均为教学设定。
# file: agp_lab/loop_control.py | write
# tier: 3
# verify: python3 -m unittest tests.test_loop_control
"""控制循环与停止条件:任务、步数、时间、资源四层。
Agent 的循环不是 while True 加一句“完成后停止”,而是一个带显式停止
条件的状态机。本模块用脚本化的步长与成本模拟三类运行:永不完成的任务、
完成得较慢的任务、以及成本先到上限的任务,比较只靠任务条件与四层条件
全开时的漏停和早停。
"""
from __future__ import annotations
from dataclasses import dataclass
TASK = "task"
STEPS = "steps"
TIME = "time"
RESOURCE = "resource"
ORDER = (TASK, STEPS, TIME, RESOURCE)
TASK_ONLY = frozenset({TASK})
ALL_LAYERS = frozenset(ORDER)
@dataclass(frozen=True)
class Limits:
max_steps: int
time_budget: float
cost_budget: float
def __post_init__(self) -> None:
if self.max_steps < 1:
raise ValueError("max_steps 必须为正")
if self.time_budget <= 0 or self.cost_budget <= 0:
raise ValueError("时间与成本预算必须为正")
@dataclass(frozen=True)
class StepPlan:
seconds: float
cost: float
@dataclass(frozen=True)
class RunResult:
solved: bool
steps: int
elapsed: float
cost: float
stop_reason: str
def stop_reason(
steps: int,
elapsed: float,
cost: float,
solved: bool,
limits: Limits,
layers: frozenset[str] = ALL_LAYERS,
) -> str | None:
"""按固定优先级返回第一个命中的停止条件。"""
unknown = layers - ALL_LAYERS
if unknown:
raise ValueError(f"未知停止层: {sorted(unknown)}")
if TASK in layers and solved:
return TASK
if STEPS in layers and steps >= limits.max_steps:
return STEPS
if TIME in layers and elapsed >= limits.time_budget:
return TIME
if RESOURCE in layers and cost >= limits.cost_budget:
return RESOURCE
return None
def run(
plan: tuple[StepPlan, ...],
limits: Limits,
layers: frozenset[str] = ALL_LAYERS,
solved_at: int | None = None,
) -> RunResult:
"""执行脚本化步骤,返回停止时的状态。
solved_at 表示执行完第几步后任务完成(1 起计)。脚本耗尽而没有任何
条件命中时记为 exhausted:这正是“漏停”的形态。
"""
steps = 0
elapsed = 0.0
cost = 0.0
while True:
solved = solved_at is not None and steps >= solved_at
reason = stop_reason(steps, elapsed, cost, solved, limits, layers)
if reason is not None:
return RunResult(solved, steps, elapsed, cost, reason)
if steps >= len(plan):
return RunResult(solved, steps, elapsed, cost, "exhausted")
spend = plan[steps]
elapsed += spend.seconds
cost += spend.cost
steps += 1
@dataclass(frozen=True)
class Scenario:
name: str
plan: tuple[StepPlan, ...]
limits: Limits
solved_at: int | None
def _plan(count: int, seconds: float, cost: float) -> tuple[StepPlan, ...]:
return tuple(StepPlan(seconds, cost) for _ in range(count))
SCENARIOS = (
Scenario("runaway", _plan(20, 2.0, 0.01), Limits(4, 10.0, 0.05), None),
Scenario("slow-solve", _plan(10, 6.0, 0.01), Limits(8, 10.0, 0.50), 3),
Scenario("cost-bound", _plan(10, 1.0, 0.02), Limits(10, 20.0, 0.05), 5),
)
def compare(
cases: tuple[Scenario, ...] = SCENARIOS,
policy: str = "full",
) -> list[tuple[str, RunResult]]:
layers = TASK_ONLY if policy == "task-only" else ALL_LAYERS
return [(case.name, run(case.plan, case.limits, layers, case.solved_at)) for case in cases]
if __name__ == "__main__":
for policy in ("task-only", "full"):
print(f"policy={policy}")
for name, result in compare(policy=policy):
solved = "yes" if result.solved else "no"
print(
f" {name:<12}steps={result.steps:<3}elapsed={result.elapsed:>6.1f}"
f" cost={result.cost:>5.2f} solved={solved:<3} stop={result.stop_reason}"
)
运行:
cd private/labs/agp-lab
python3 -m agp_lab.loop_control
输出:
policy=task-only
runaway steps=20 elapsed= 40.0 cost= 0.20 solved=no stop=exhausted
slow-solve steps=3 elapsed= 18.0 cost= 0.03 solved=yes stop=task
cost-bound steps=5 elapsed= 5.0 cost= 0.10 solved=yes stop=task
policy=full
runaway steps=4 elapsed= 8.0 cost= 0.04 solved=no stop=steps
slow-solve steps=2 elapsed= 12.0 cost= 0.02 solved=no stop=time
cost-bound steps=3 elapsed= 3.0 cost= 0.06 solved=no stop=resource
这张表展示了两类典型问题。
漏停。 只靠任务层时,runaway 跑到步数上限才以 exhausted 停止,花费是 full 策略下的五倍;cost-bound 更是以 task 正常退出,根本没人发现成本超限。停止条件不是"存在",而是"有效":没有独立的步数、时间、资源层,任务层在需要停的时候根本不会触发。
早停。 full 策略下,slow-solve 在 2 步就被 time 层拦下(solved=no),而它在 task-only 下 3 步能完成。这不是实验的缺陷,而是现实中的权衡:预算本身有成本。把时间预算设得太紧,会把"慢但能完成"的任务提前杀掉;设得太松,又拦不住 runaway。预算不是越大越好,也不是越小越好,而是要根据任务的真实分布来定。
cost-bound 在 full 下以 resource 停止:它消耗的 token 达到上限,即使再试一次就能完成,也必须终止。这里有个容易被忽略的点:终止不等于完成。强制终止后,Agent 的状态必须能交接——记录做到哪一步、缺什么、为什么停,否则下次运行要从头再来,成本反而更高。
停止条件必须是运行时约束
为什么停止条件不能只写在提示词里?有三个原因:
- 提示词是建议,不是约束。 模型可以忽略"最多调用十次",继续调用。
- 提示词无法计量。 token 数、金额、墙钟时间在模型输出里根本看不到,必须由运行时统计。
- 提示词不可审计。 你想知道"这次运行为什么花了这么多钱",提示词不会告诉你;运行时日志才会。
所以停止条件要实现为运行时的不变量:由循环框架统一检查,Agent 内部的每一步动作都不能绕过。任何"我马上就好,再给我一次机会"的请求,都必须通过停止谓词,而不是直接放行。
架构含义
控制循环对架构有三个直接约束:
- 循环体要有确定的单步语义。 每一步要么推进状态,要么明确失败;没有"既不推进也不失败"的分支。
- 停止谓词与模型解耦。 模型决定做什么,运行时决定能不能继续;两者用同一个状态接口连接。
- 终止必须留下交接记录。 达到哪一层上限、已完成了哪些子目标、剩余哪些未决项,都要可读、可重放。
第 2 条是"Agent 可靠"的前提。模型是策略的一部分,不是整个 Agent;把停止权交给模型,等于把系统边界交给一个概率分布。
架构判据
| 判据 | 合格的样子 | 不合格的样子 |
|---|---|---|
| 分层停止 | 任务/步数/时间/资源四层齐全 | 只有一句"完成后停止" |
| 运行时实现 | 循环框架统一检查 | 在提示词里提醒模型 |
| 优先级声明 | 超限顺序写死并文档化 | 各实现各自判断 |
| 终止留痕 | 有停止原因与进度快照 | 只留下一句超时错误 |
| 预算可配 | 每类任务单独配上限 | 全局一个死数值 |
这些判据里,“分层停止"是底线。没有后三层,任何"Agent 一直花我们的钱"的故障都会归因到模型,而真正的缺口在控制循环。
与三条工作负载的关系
三条工作负载对停止条件的敏感度不同:
- W1 检索问答(3–8 步):步数层最重要,防死循环;时间层 p95≤8s 直接进延迟预算。
- W2 代码修复(10–40 步):任务层判定"测试通过"最有用,步数层兜底;预算要按成本配。
- W3 运维处置(2–6 步):不可逆动作必须在动作层拦停,资源层不能取代审批。
W3 有个特别之处:它的停止不完全是"停下”,而是"停下来等人审批"。停止条件在这里不是成本的护栏,而是权限的边界。这是下一节进展度量能帮你判断"该不该继续"的基础。
小结
- Agent 循环是一个带显式停止谓词的控制循环,终止权不在模型,在运行时。
- 停止条件至少分任务、步数、时间、资源四层,任何一层先超限都要终止。
- 只靠任务层会漏停:任务没进展时没有任何独立信号拉停循环。
- 预算同时带来早停:时间或资源设太紧,会杀掉本可完成的任务。
- 终止不等于完成:强制终止后必须留下可交接的进度记录。
- 停止谓词必须在运行时实现,提示词只能建议,不能约束。
阅读导航:上一节:1.3 LLM 作为策略:提示是历史的有损压缩 · 下一节:2.2 进展度量与死循环检测 。
常见错误与边界
- 把停止权交给模型。 “完成后停止"是建议不是约束;模型倾向继续做事,会系统性漏停。
- 只实现任务层。 没有步数、时间、资源上限,死循环和成本失控只是时间问题。
- 预算设成全局死值。 三类负载的步数与成本分布不同,全局一个上限不是拦住就是误杀。
- 终止当完成。 强制终止后直接返回空结果,丢失进度;必须留下交接记录。
- 忽略优先级。 多层同时超限时没有写死的检查顺序,不同实现会给出不同的终止。
- 把预算设越大越好。 预算同时是约束也是成本;要按任务分布调,不是一律放开。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。