观点

多 agent 越加越烂?问题出在并发控制

arXiv 一篇 position paper 把 MAS 失败模式重新框定为并发问题。LLM 推理窗口长 = 长事务,stale read、lost update 全部复现。

字号

多 agent 越加越烂?问题出在并发控制

最近翻到 arXiv 上一篇 position paper(arXiv:2608.18092),观点很直接:现在多 agent 系统(MAS)的可靠性问题,根子是并发控制没做好。换句话说,不是 prompt 写得不好,也不是模型不够聪明,是大家在没锁的数据库上跑事务。

这个类比越想越觉得对。下面把论文核心论点 + 我自己搭 demo 时的观察拼在一起讲。

加 agent 反而更糟,不是玄学

adding agents often reduces reliability——加 agent 越多,可靠性越低。

我自己搭过的几个 demo 也复现过这条曲线:3 个 agent 协作,跑 10 次能稳 8 次;上到 7、8 个,能稳 4 次就不错了;硬塞到 12 个以上,基本是看运气。

大多数人会甩锅给 prompt 不够好、模型推理能力不够、上下文太长。论文给的判断不一样:这些失败的根因,大多是并发问题。

把 LLM 推理延迟当成"长事务"看

数据库圈有个老梗:长事务是万恶之源。一个事务跑了几十分钟,期间别人改了它要读的数据,等它提交时拿到的就是 stale read,严重的还会 dirty write。

LLM 推理就是天然的长事务。

  • 一次 GPT-4o / Claude 调用,从发请求到拿到完整响应,3 秒算快的,复杂 tool use + 推理 30 秒很常见
  • 这 30 秒里,其它 agent 完全可能已经改完了共享状态
  • 等这个 agent 拿着"过时的事实"返回写入,覆盖掉别人的更新——lost update

论文里原话:long LLM inference windows amplify the risk of stale reads, lost updates, and inconsistent outcomes。把这段话里的 "LLM inference window" 换成 "transaction",丢进任何一本数据库教材都成立。

经典并发异常在 MAS 里全部复现

论文最关键的一段:failure modes commonly attributed to coordination or communication breakdowns can be mapped directly onto classical concurrency anomalies。

翻译成大白话:你们以为的"协调失败",大多数是经典并发 bug 换了个皮。几个我自己踩过的:

Lost update(更新丢失)

两个 agent 同时拿到用户偏好 A=[tech, music],各自推理后写入:
- Agent 1 写回 A=[tech, music, cooking]
- Agent 2 写回 A=[tech, music, sports]

谁后写谁赢,前一个 agent 的增量直接蒸发。这跟两个事务同时改同一行记录是一回事。

Dirty read(脏读)

Agent A 把任务状态从 pending 改成 in_progress,正在执行。Agent B 在 A 还没完成时读了状态,看到 in_progress 就基于这个做了下游决策。结果 A 失败回滚到 pending,B 的决策建立在已经不存在的状态上。

Write skew(写偏斜)

两个 agent 各自基于"对方不会改"的假设写入。经典的医生排班问题:两个医生各自看了排班表,发现"只要对方不加班我就不需要加班",结果两个人都没排上。MAS 里这就是两个 agent 各自基于快照做决策,最后合并出不一致状态。

这些不是理论推演,是我在 CrewAI、LangGraph 里都跑出来过的真实行为。

现有框架为什么没内置并发控制

主流 agent 框架——AutoGen、CrewAI、LangGraph——设计时都有一个隐含假设:agent 调用是短平快的 RPC。

# LangGraph 里典型的节点写法
def research_node(state: AgentState):
    result = llm.invoke(state["messages"])
    return {"messages": [result]}

看起来是函数调用,底下其实是几秒到几十秒的阻塞 I/O。框架没提供任何机制让你:
- 在 invoke 期间锁住 state
- 检查返回值是不是基于最新的 state
- 处理"别人在我推理时改了我依赖的数据"

更糟的是,agent 间的"通信"本质上是共享状态(一个 dict / 一个消息队列),没有事务边界,没有隔离级别,没有任何 ACID 保证。你以为在写工作流,其实是在裸跑并发。

论文的判断很直接:等于在没锁的数据库上跑事务——不,比那还烂,因为数据库至少有 WAL。

从数据库抄作业:锁、版本号、事务隔离

论文建议 MAS 框架在设计阶段就内置并发控制。具体怎么抄?我把论文给的思路 + 自己的实验整理一下。

悲观锁(pessimistic locking)

agent 开始一项需要修改共享状态的任务前,先显式锁住相关字段。其他 agent 想读就阻塞,等锁释放。

# 伪代码
with state.lock("user_preferences"):
    current = state.read("user_preferences")
    new = agent.run(current)
    state.write("user_preferences", new)

缺点明显:LLM 推理慢,锁持有时间太长,并发度直接归零。但对一致性要求高的场景(金融、订单)值得。

乐观锁 + 版本号(optimistic concurrency control)

每个共享对象带一个 version 字段。写入前 CAS 检查版本号,没变才写,变了就重试。

version = state.read("user_preferences.version")
prefs = state.read("user_preferences")
new_prefs = agent.run(prefs)
state.cas_write(
    key="user_preferences",
    expected_version=version,
    value=new_prefs,
)

这模式适合读多写少的 agent 协作。重试逻辑里要带新数据,不然又退化成 lost update。

事务隔离(transaction isolation)

把一次 agent 协作(多个步骤 + 多次状态读写)包成一个事务。隔离级别从低到高:
- Read uncommitted:基本没用
- Read committed:避免脏读
- Repeatable read:避免不可重复读
- Serializable:完全隔离,性能最差

MAS 里大多数场景用 read committed 就够了,关键决策点(写入)走 serializable。

CRDT(conflict-free replicated data type)

论文没明说,但我自己试过 CRDT 解决一类 MAS 问题:多方各自追加、不需要严格顺序的场景。

比如多个 agent 各自往共享笔记里加 bullet point,最后合并是无冲突的。Yjs 这类库直接能用,比搞锁简单太多。

这事没人做,是因为 agent 框架还在"能用就行"阶段

现在的 MAS 框架还在卷"几行代码搭一个 agent 团队"。

  • CrewAI 主打快速搭团队
  • AutoGen 把"对话即协作"当卖点
  • LangGraph 强调可视化工作流

并发控制这种脏活累活,没人愿意碰。短期看也确实没必要——demo 阶段 3 个 agent 跑得挺欢乐,谁管它生产环境会不会崩。

但凡你认真往生产推过 MAS,就会撞上今天说的这些问题。不是 prompt 能修的,不是换更强的模型能修的,必须从架构层面引入并发原语。

想自己验证的话,按这个顺序来

  1. 拿 CrewAI 或 LangGraph 搭一个 ≥5 agent 的 demo,让两个 agent 同时写同一份共享状态(用户偏好、任务列表都行)
  2. 跑 20 次以上,记录 lost update / dirty read 出现频率
  3. 给共享对象加 version 字段 + CAS 写入,看稳定性提升
  4. 一致性要求高(涉及金额、订单状态)的写入路径上 serializable,别走乐观并发

如果你只想从这篇论文带走一句话:你遇到的不是"AI 不可靠",是"没做并发控制"。这么想完,解法就明确了——去数据库领域抄作业就行。

参考:arXiv:2608.18092 - Concurrency Control for Multi-Agent Systems

来源: https://arxiv.org/abs/2608.18092