《AI Agent 技术原理与架构·运行时、协议与系统架构》10.2 仲裁:多数、优先级与版本

多个智能体意见不一致时,谁说了算?多数仲裁数人头、平局要有裁决;优先级仲裁按权威排座次;版本仲裁按新旧的合理程度裁决。三种策略各有适用场景,可以组合——先多数、平局用优先级。实验实现三种仲裁函数并演示平局、优先级打破平局、版本裁决,说明仲裁策略是显式决策而不是默认行为。

以下投票与优先级数值均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。“多数遇平局要裁决、优先级是显式配置、版本比新旧合理"这三条不变,具体票型与权重按业务实测。

10.1 讲了责任怎么转移,这一节讲多个智能体意见不一致时怎么办。仲裁是协调的第二件动作:谁说了算。多数、优先级、版本是三种不同的裁决逻辑,可以组合,但仲裁策略必须是显式决策——默认行为最容易埋错。

多数仲裁:数人头,但平局要裁决

多数仲裁最直观:几个智能体各自表态,票数过半的赢。多数的问题在平局——2:2 时没有人过半。平局不是"重投一次"那么简单,它说明多数策略本身裁不了这个局,要交给规则。

票型裁决
2:1少数服从多数,出结果
2:2平局,无多数可依
3:0压倒多数,出结果

平局必须显式暴露,不能假装有结果。模块里多数平局返回 tie——把"没有人说了算"明说出来,让上层决定下一步。这是仲裁诚实性的起点。

优先级仲裁:权威排座次

优先级仲裁按权威裁决:每个智能体有个优先级,冲突时优先级高的赢。优先级是显式配置,不是默认行为——谁比谁权威,要写进配置而不是看消息顺序。

参与者优先级冲突时
安全策略 agent高否决业务建议
业务 agent低让位给安全

优先级还能打破多数平局。 2:2 平局时,多数策略裁不了,但优先级可以——如果两票里的一个来自高优先级,就按它走。多数与优先级组合:先多数,平局再上优先级。

版本仲裁:按新旧合理性裁决

版本仲裁按版本新旧裁决:同一议题两个答案,版本新(或更新)的赢。版本的合理性在于"新"通常意味着"修正过”——但要注意,新不是天然正确,版本仲裁只比新旧,不比质量。

场景版本裁决
同一配置两版v2 修正过 v1采纳 v2
两版来自不同来源版本无意义换策略

最小实验:三种仲裁函数

实验实现 majority、priority_arbitration、version_arbitration,并演示平局、优先级打破平局、版本裁决。

# file: agp_lab/arbitration.py | write
# tier: 3
# verify: python3 -m unittest tests.test_arbitration
"""共识、仲裁与冲突消解:多数一致与权威仲裁。

多个 Agent 对同一决策给出不同意见时,需要冲突消解。本模块实现
三种机制:多数表决(quorum)、优先级仲裁(priority)、版本仲裁
(最新版本)。演示同一条冲突意见在三种机制下的结果差异。
"""
from __future__ import annotations

from collections import Counter
from typing import Any


def majority(opinions: dict[str, str]) -> str:
    """多数表决:票数最高的意见胜出。"""
    counts = Counter(opinions.values())
    top = counts.most_common(2)
    if len(top) > 1 and top[0][1] == top[1][1]:
        return "tie"
    return top[0][0] if top else "empty"


def priority_arbitration(
    opinions: dict[str, str], priority: dict[str, int]
) -> str:
    """优先级仲裁:最高优先级的意见胜出;同优先级回到多数。"""
    best_priority = max(priority.get(agent, 0) for agent in opinions)
    top_agents = [a for a in opinions if priority.get(a, 0) == best_priority]
    if len(top_agents) == 1:
        return opinions[top_agents[0]]
    return majority({a: opinions[a] for a in top_agents})


def version_arbitration(versions: dict[str, int]) -> str:
    """版本仲裁:最新版本的意见胜出,返回该版本的作者。"""
    latest_author = max(versions, key=lambda a: versions[a])
    return latest_author


def demo() -> dict[str, Any]:
    opinions = {"alice": "deploy", "bob": "rollback", "carol": "deploy"}
    priority = {"alice": 1, "bob": 2, "carol": 1}
    versions = {"alice": 3, "bob": 5, "carol": 2}

    split = {"alice": "A", "bob": "B", "carol": "B"}
    tie = {"alice": "A", "bob": "B", "carol": "A", "dee": "B"}
    return {
        "majority_2_1": majority(opinions),
        "majority_2_2_tie": majority(tie),
        "priority_wins": priority_arbitration(opinions, priority),
        "version_latest": version_arbitration(versions),
        "priority_breaks_tie": priority_arbitration(tie, priority),
    }


if __name__ == "__main__":
    for key, value in demo().items():
        print(f"{key}: {value}")

运行:

cd private/labs/agp-lab
python3 -m agp_lab.arbitration

输出:

majority_2_1: deploy
majority_2_2_tie: tie
priority_wins: rollback
version_latest: bob
priority_breaks_tie: B

五条输出对应五件事:

  1. majority_2_1:2:1 表决,多数赢,结果 deploy。多数在票数分明时直接出结果。
  2. majority_2_2_tie:2:2 平局,返回 tie。平局是显式的——没有人过半,多数策略认输。
  3. priority_wins:优先级仲裁,高优先级赢,结果 rollback。权威排座次,不问票数。
  4. version_latest:版本仲裁,新版本赢,结果 bob。版本比新旧,更合理的版本胜出。
  5. priority_breaks_tie:2:2 平局时用优先级打破,高优先级一方赢,结果 B。多数与优先级组合——平局交给权威。

一个值得点破的细节:majority_2_2_tie 返回 tie 而不是硬选一个——这是仲裁诚实性的分水岭。一个实现如果平局也返回结果,等于在票数不够时伪造了多数意志。显式返回 tie 把"没人说了算"交给上层,而 priority_breaks_tie 演示了正确的组合:平局不硬选,而是切换到优先级规则。

仲裁策略的组合

三种策略不是互斥的,是按层组合的:

层策略用途
第一层多数票数分明时快速裁决
第二层优先级平局时按权威破
第三层版本同一来源的新旧裁决

组合的顺序是架构决策。 多数先跑、平局上优先级、同源新旧用版本——这个顺序要显式设计,而且要能回答"平局为什么这样破"。策略组合是 10.2 的核心产物,不是三种函数各用各的。

仲裁与责任链、死锁的接口

仲裁不是孤立的裁决,它消费责任链、服务死锁检测。仲裁要问"每票代表谁"——10.1 的责任链提供这个答案:优先级仲裁查责任者身份,版本仲裁查责任链上的新旧。死锁(10.3)是协调的另一半:仲裁管"意见不一怎么办",死锁检测管"互相等待怎么办"。一个多智能体系统先要能裁决冲突(10.2),再要能防互相等待(10.3)。

仲裁的可复现性

仲裁结果必须可复现。同样一组意见,任何时候仲裁都应得到同样的结果——不能依赖消息到达顺序、随机数或"先到先得"。多数和优先级是确定性的,版本仲裁要小心"版本号相等"的边界。仲裁的确定性能让 12 章的可观测性有意义:追踪看到的结果,重放时能复现,调试才能进行。

策略确定性边界
多数确定平局显式暴露
优先级确定优先级相等退化多数
版本确定版本相等要另定规则

权重仲裁

多数仲裁的进阶是权重仲裁——不是每票一样重,关键角色票重。安全策略 agent 的票权重 3,业务 agent 权重 1,加权重票胜过人头票。权重把"谁的判断更重要"量化进仲裁,比人头更贴业务。

参与方权重理由
安全策略3一票顶三票
业务1参考意见
平台2折中

权重仲裁的平局判定要重算。 人头平局可能权重不平局——2 个人头平局,但权重 3 的一方赢了。权重仲裁同样要处理平局(权重和相等),这时退回优先级或版本。权重的设定与优先级是同一类配置:谁更重要,写进配置而不是消息顺序。

仲裁的异常与降级

仲裁器本身会出问题。仲裁器挂掉,冲突谁来裁? 要么仲裁器冗余(主备),要么降级(默认规则:平局默认保守动作)。降级要显式声明——“仲裁不可用期间,冲突默认走最保守路径”,而不是让冲突无人处理。

仲裁器状态行为
正常按策略裁决
不可用主备切换
持续不可用降级默认保守

仲裁降级与 11 章容错接缝——仲裁器是协调的关键组件,它的可用性要像熔断器(11.2)一样有状态。仲裁器失联检测、降级规则,都要写进系统,而不是等冲突堆起来才反应。

仲裁与决策质量

仲裁只裁决"听谁的",不保证"裁决是对的"。多数可能多数都错,优先级可能是过时的权威——仲裁给的是"可执行的决定",不是"正确的结果"。决策质量要另靠评估:裁决后跑断言(12.2)、统计验证(12.3),才能知道这个裁决好不好。

层回答
仲裁听谁的
评估裁决对不对
追踪裁决怎么发生的

仲裁是决策的"程序正义",评估是"结果正义"。 两者都要——程序上裁决可复现、有依据,结果上裁决经得起评估检验。仲裁与评估的接口,是智能体系统决策质量的完整闭环。

仲裁的输入校验

仲裁要校验输入。票要合法:谁投的、投了什么、票型是否有效——匿名投票、重复投票、越权投票都要拦。仲裁器的正确性不只靠裁决逻辑,还靠输入完整性。无效票混进来,多数仲裁的多数就是假的。

校验拦什么
投票者匿名、越权
票型非 A/B 选项
重复一票多投

输入校验与 13.2 的纵深防御呼应——仲裁器是协调的关键组件,它自己的输入校验是第一层防御。仲裁结果要可复现,输入不干净,复现就是复现一个错的。

仲裁的失败

仲裁器调用本身会失败。下游取不到票、票超时未达——仲裁在票不齐时怎么办?多数仲裁可以等超时再裁(未到的票弃权),优先级仲裁可以直接裁(权威不受缺席影响)。缺票处理是仲裁策略的一部分,写进设计而不是临场决定。

缺票处理
少数缺席超时后按到场票裁
关键票缺席等待或降级
全体缺席降级默认

缺票与 11 章容错接缝——票缺席本质是失败(11.1 分类),仲裁器要按失败处理缺席:可重试等一程、致命就当弃权。仲裁的可用性依赖对缺票的容错设计。

架构判据

仲裁是否合格,用五条判据检查:

判据合格的样子不合格的样子
平局显式平局返回 tie平局伪造结果
优先级可配置权威写入配置权威默认行为
版本有边界版本相等有规则版本相等乱裁
组合可设计策略按层组合三种各用各的
结果可复现重放结果一致依赖顺序或随机

判据第一条是"平局必须显式暴露",判据第四条才是关键:三种策略要能按层组合,多数平局上优先级。判据第五条是可观测性的前提——仲裁不确定,追踪就追不到真相。

小结

  • 多数仲裁数人头,平局显式返回 tie,不伪造结果。
  • 优先级仲裁排座次,权威是显式配置。
  • 版本仲裁比新旧,版本相等要有边界规则。
  • 三种策略按层组合:多数→优先级→版本。
  • 仲裁结果要可复现,可观测性才有意义。

阅读导航:上一节:10.1 委托与交接:责任如何转移 · 下一节:10.3 死锁:环检测与预算 。

常见错误与边界

  1. 平局伪造结果。 票数不够就硬选,等于伪造多数意志。
  2. 优先级当默认。 权威要写配置,不能靠消息顺序隐式决定。
  3. 版本仲裁当质量。 版本只比新旧不比质量,新不等于对。
  4. 三种策略各用各的。 平局要靠优先级破,组合要显式设计。
  5. 仲裁不可复现。 结果依赖顺序或随机,追踪与调试无从下手。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图