有一家餐厅的后厨,曾经只有一个厨师:点单、洗菜、切菜、炒菜、尝味、摆盘,全由他一人包办。平时三两桌客人尚能应付,可一旦客人点了“一桌家宴”,他就手忙脚乱——不是把菜炒糊,就是忘掉主菜。后来店长想出一个办法:把后厨拆成两个岗位。一位主厨负责定标准、发指令、尝味道;一位帮厨负责具体下锅执行。两人隔着传菜口你一言我一语地配合,居然把“家宴”稳稳做了下来。 这个故事里的“两个岗位”,就是两个各司其职的智能体(Agent);他们一来一回的对话,就是“协作推理”。AI 领域有一个名为 CAMEL 的框架,正是把“一个模型包办所有事”改造成“两个模型角色扮演式地配合”,从而啃下复杂任务。本文就用“主厨与帮厨”这个比喻,带你拆开 CAMEL 的角色模拟协作推理链:角色怎么分、任务怎么定、推理怎么传、如何收尾。

岗位关联

学透 CAMEL,你就掌握了多 Agent 协作的骨架。这是从“只会调单个模型”走向“能搭建 Agent 团队”的关键一步,也是 AI 应用工程师、Agent 产品经理绕不开的核心范式。

目录
  1. 可视化演示
  2. 框架诞生背景
  3. 角色分配机制
  4. 任务初始化
  5. 推理传递链
  6. 协作决策机制
  7. 思维链应用
  8. 实战应用场景
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示CAMEL框架中AI User与AI Assistant角色模拟协作、推理链传递机制及多轮对话任务求解过程。

本节配有交互动效(进入视口后自动加载,约 3KB)。

角色模拟协作架构 AI User: 发出指令和需求 AI Assistant: 提供方案和执行 Inception Prompting → 角色行为约束 两个Agent通过角色扮演实现自主协作。

框架诞生背景

曾有一位厨师独自撑起整家后厨:点单、备菜、炒制、调味、摆盘,全靠他一人。平时三两桌客人尚能应付,一旦遇到“满汉全席”,他就顾此失彼——菜不是炒糊,就是放凉。这就是单 Agent 的真实处境:一个“脑子”既要理解目标、又要拆解步骤、还要自查质量,上下文一长就容易跑偏。

研究者很快意识到,与其把所有压力压在一个模型身上,不如学后厨“增设岗位”。CAMEL 框架(Communicative Agents for "Mind" Exploration of Large Language Model Society)把一次复杂任务交给两个角色:AI 用户(AI User)和 AI 助手(AI Assistant)。两者各自维护完整的对话历史,在系统提示词里写明角色与守则,随后在一轮轮真实对话中交替贡献推理,把模糊目标逐步推进为可交付结果。

一次完整的协作推理,从外部看就是一条有序的消息序列:

有了两个岗位,后厨就从“一个人硬扛”变成“两个人接力”。但岗位不能空有名头,接下来要解决的是:主厨与帮厨的职责边界到底怎么定?这就是角色分配机制。

D=⟨m1(user),  m1(assistant),  m2(user),  m2(assistant),  …,  mT(done)⟩\displaystyle D = \left\langle m_1^{\text{(user)}},\; m_1^{\text{(assistant)}},\; m_2^{\text{(user)}},\; m_2^{\text{(assistant)}},\; \ldots,\; m_T^{\text{(done)}} \right\rangle
消息序列就像一张越写越长的传菜单:交替出现的发件人、逐步推进的内容,把“两个模型怎么配合”完整记录了下来。
  1. 对话记录 D表示一次协作推理中双方交换的全部消息集合,是推理链的外部形态。
    D=⟨…⟩D = \left\langle \ldots \right\rangle
  2. 单条消息 m某一轮里某一方发出的一条自然语言消息,相当于传菜口递出的一张纸条。
    mt(role)m_t^{\text{(role)}}
  3. 轮次下标 t表示这是第 t 轮交互,序号越大越靠后,推理也越深入。
    t∈{1,2,…,T}t \in \{1, 2, \ldots, T\}
  4. 发送方上标标注消息来自用户方还是助手方,决定下一步推理由谁推进。
    (user),  (assistant)\text{(user)},\; \text{(assistant)}
  5. 终止消息 m_T序列末尾记录任务完成信号,表示协作循环在此收尾。
    mT(done)m_T^{\text{(done)}}

角色分配机制

主厨和帮厨在开工前都要领到自己的“工牌”:主厨的工牌写着“你负责定标准、发指令、尝味道”,帮厨的工牌写着“你负责按指令出菜、汇报进展”。CAMEL 里的角色分配,就是给两个模型各发一张这样的工牌——把角色身份写进各自的系统提示词,让它们一开口就知道自己该说什么话。

在 CAMEL 中,AI 用户角色相对固定:它是协作的发起者与验收者,负责把大目标拆成一条条指令,并对助手返回的方案做质量判断。AI 助手角色则通常从具体任务中推断而来:任务要写代码,助手就是“代码工程师”;任务要算数学题,助手就是“数学研究员”。这种“一虚一实”的搭配,正好对应主厨掌握方向、帮厨掌握技法。

从任务到角色,可以形式化地看作一次角色推断:

工牌发完,两个 Agent 却面临一个尴尬问题:客人只说了句“来一桌家宴”,主厨和帮厨都不知道具体做什么。开工前还差一道工序——把模糊需求变成具体菜单。

T→角色推断(ruser,  rassistant)\displaystyle \mathcal{T} \xrightarrow{\text{角色推断}} \left( r_{\text{user}},\; r_{\text{assistant}} \right)
主厨工牌是固定制作的,帮厨工牌却要根据今天这桌菜现写——角色推断就是那个“现写工牌”的动作。
  1. 原始任务 TT 是给定的宽泛目标,比如“开发一个选股机器人”。
    T\mathcal{T}
  2. 角色推断箭头借助大模型从任务内容中推断出合适的角色分工。
    →角色推断\xrightarrow{\text{角色推断}}
  3. 用户角色 r_user代表发指令、做验收一方,是协作的掌舵者。
    ruserr_{\text{user}}
  4. 助手角色 r_assistant代表具体执行、产出方案的一方,是协作的操盘手。
    rassistantr_{\text{assistant}}
  5. 角色二元组两个角色组合成一对,后续所有对话都在这个角色框架下进行。
    (ruser,  rassistant)\left( r_{\text{user}},\; r_{\text{assistant}} \right)

任务初始化

客人嘴里那句“来一桌家宴”实在太模糊。聪明的后厨会先和客人确认:是川菜还是粤菜?几个人吃?有没有忌口?然后写出一份具体菜单。CAMEL 的任务初始化(Task Inception)做的就是这件事:在正式开始协作前,先把宽泛目标改写成一份“具体任务说明”。

任务初始化借助一个“知识提示(Knowledge Prompt)”:提示词先交代原始任务,再引导模型产出“助手需要完成的具体任务是什么”。大模型给出的结果是一个“指令(Instruction)+ 输入(Input)”对——指令是细化的任务描述,输入是任务附带的上下文数据。同时,这个具体任务还会顺带决定助手扮演什么角色,一举两得。

将这个过程写成公式:

菜单定好了,主厨和帮厨终于可以开工。但他们之间怎么传话?传菜口立了什么规矩?这就进入整条协作链最核心的一环——推理传递链。

Stask=LLM(Pknowledge(T))\displaystyle S_{\text{task}} = \text{LLM}\left( P_{\text{knowledge}}\left( \mathcal{T} \right) \right)
知识提示像一份“菜单设计问卷”,大模型像主厨,填完问卷就得到一张可执行的菜单——具体任务说明。
  1. 原始任务 T刚开始收到的模糊目标,如“写一个爬虫程序”。
    T\mathcal{T}
  2. 知识提示 P一段专门引导模型给出具体任务的提示模板,内含任务背景与要求。
    Pknowledge(⋅)P_{\text{knowledge}}(\cdot)
  3. 大模型计算 LLM把知识提示送入大模型做一次生成,得到结构化的任务说明。
    LLM(⋅)\text{LLM}(\cdot)
  4. 具体任务 S_task模型产出的具体任务说明,包含指令与输入两部分。
    StaskS_{\text{task}}
  5. 等号关系右边生成的结果就是左边最终采用的协作起点。
    Stask=…S_{\text{task}} = \ldots

推理传递链

后厨的传菜口有条不成文的规矩:帮厨每递出一份菜,必须附带三样信息——“我这道菜是怎么做的”(方案)、“请主厨检查”(沟通)、“下一道菜要什么”(请求)。CAMEL 的协作循环把这套规矩写进了 AI 助手的回复格式,让每一轮对话都有产出、有汇报、有下一步的抓手。

具体来说,AI 助手每轮回复被约束为三段式:第一段“解决方案”,针对当前指令给出方案正文;第二段“给 AI 用户的话”,向用户汇报状态、请对方确认;第三段“下一次请求”,请用户继续下发下一步指令。AI 用户收到后,要么下达新指令,要么在验收无误后发送终止信号。如此循环,推理就在一问一答之间逐层接力。

助手第 t 轮的完整回复可以记为:

传菜口的规矩让每一轮交互都结构清晰。但光有规矩还不够——主厨尝到菜觉得淡了,是喊“加盐”还是直接“上菜”?这个决策动作,就是协作决策机制。

Mt(A)=[St;  Ct;  Rt]\displaystyle M_t^{(A)} = \left[ S_t;\; C_t;\; R_t \right]
这条公式就是帮厨端菜的“托盘”:方案是菜本体,给用户的话是报菜名,下一次请求是问下一道菜做什么。
  1. 助手消息 M第 t 轮 AI 助手发出的完整回复,是推理链上的一个节点。
    Mt(A)M_t^{(A)}
  2. 解决方案 S_t针对当前指令给出的方案正文,是协作的实质产出。
    StS_t
  3. 给用户的话 C_t向 AI 用户汇报进展、请求确认的沟通消息。
    CtC_t
  4. 下一次请求 R_t请 AI 用户继续下发下一步指令,保证循环不中断。
    RtR_t
  5. 方括号拼接三段按固定顺序组合成一条完整消息,缺一不可。
    [St;  Ct;  Rt]\left[ S_t;\; C_t;\; R_t \right]

协作决策机制

主厨不是传声筒,他每收到一道菜都要尝一口:淡了就让帮厨加盐,咸了就让帮厨重做,色香味俱全才点头上菜。CAMEL 里的 AI 用户同样承担着“尝菜”职责——它要根据助手每一轮的方案,判断目标是否达成,从而决定是继续下达新指令,还是结束协作。

这种决策贯穿整个推理链:如果助手的方案偏离需求,用户就发指令澄清,要求修正;如果方案基本到位但细节不足,用户就要求迭代补充;只有当验收通过时,用户才会在下一轮消息里发出终止信号。这个信号就是 CAMEL 约定的特殊标记 CAMEL_TASK_DONE。它可以形式化地写成一个分支结构:

有了决策机制,协作不会无限空转。但还有一个细节值得深挖:帮厨炒菜时自己心里也有步骤——洗菜、切菜、热锅、下油。这种“一个人内心的分步思考”,在 CAMEL 里又扮演什么角色?

ut+1={CAMEL_TASK_DONE若目标已达成新指令,继续推进否则继续\displaystyle u_{t+1} = \begin{cases} \text{CAMEL\_TASK\_DONE} & \text{若目标已达成} \\ \text{新指令,继续推进} & \text{否则继续} \end{cases}
主厨的每一次“点头”或“摇头”,都对应公式里的一个分支:点头发终止标记,摇头就再递一张新菜单。
  1. 用户下一轮消息 u_{t+1}AI 用户依据助手上一轮回复,决定下一步的输出内容。
    ut+1u_{t+1}
  2. 达成判定条件当助手方案已经满足任务目标时,进入终止分支。
    若目标已达成\text{若目标已达成}
  3. 终止标记发送 CAMEL_TASK_DONE,通知助手协作结束。
    CAMEL_TASK_DONE\text{CAMEL\_TASK\_DONE}
  4. 继续推进分支方案尚有缺口时,再下发一条新指令,循环继续。
    新指令,继续推进\text{新指令,继续推进}

思维链应用

帮厨做一道宫保鸡丁,心里会默默分几步:备料、滑鸡、调汁、下锅、收汁。这种“心里有步骤”的推理方式,就是思维链(Chain-of-Thought,CoT)——让模型不直接跳答案,而是先写出中间推理步骤,再逐步得出结论。

在 CAMEL 的多 Agent 场景中,思维链出现在两个层面。第一层是“角色内推理”:角色提示词里可以明确要求“请先列出你的思考步骤,再给出方案”,于是 AI 助手回复的“解决方案”内部本身就是一条思维链。第二层是“跨轮递进”:多轮对话中,每一轮的方案都建立在此前所有消息之上,指令、方案、反馈层层叠加,整段对话在宏观上形成了一条更长的协作推理链。

单条思维链可以表示为:

思维链让单个角色“想得更细”,协作循环让两个角色“配合得更稳”。那么这套“主厨+帮厨”的模式,到底能接什么样的活?实战中要注意什么?

CoT(q)=p1→p2→⋯→pk→a\displaystyle \text{CoT}(q) = p_1 \rightarrow p_2 \rightarrow \cdots \rightarrow p_k \rightarrow a
帮厨心里的步骤链是“微观链”,主厨与帮厨一问一答的传菜过程是“宏观链”——两条链套在一起,推理才既稳又深。
  1. 问题 q进入推理的输入问题,对应菜谱上的一道菜名。
    CoT(q)\text{CoT}(q)
  2. 中间步骤 p_i每个中间结论都是下一步推理的依据,像备料、滑鸡、调汁。
    p1,p2,…,pkp_1, p_2, \ldots, p_k
  3. 推理箭头表示“由前一步推出后一步”的逻辑推演关系。
    →\rightarrow
  4. 最终答案 a经过所有中间步骤后得到的最终结论,对应出锅装盘。
    aa

实战应用场景

双人后厨模式练熟之后,什么活都敢接:满汉全席不在话下,多个灶口同时开火也行。CAMEL 的实战价值同样如此——它把复杂任务拆成“目标制定+分步执行”两段,适用于代码生成、数学求解、课程内容设计等场景。

实践中有两个关键点。一是复杂任务拆解:任务越复杂,越依赖任务初始化把目标定准,也越依赖多轮协作修正方向。二是终止条件设计:CAMEL_TASK_DONE 是双方约定的协调信号,而非系统强制的开关,因此角色提示词里要写清楚“什么情况算完成”,否则协作可能陷入反复追问的死循环。在这些约束下,研究者常用成功率来评估协作效果:

从单厨忙乱到双人配合,CAMEL 用角色模拟、任务初始化、三段式回复、验收终止这套“后厨管理法”,把多 Agent 协作推理变成了可设计、可控制、可评估的工程范式。理解了它,你就拿到了搭 Agent 团队的第一张施工图。

SR=NsuccessNtotal×100%\displaystyle \text{SR} = \frac{N_{\text{success}}}{N_{\text{total}}} \times 100\%
成功率就是“后厨的招牌口碑”:成功端出并获验收的菜数,占总接单数的比例。比例越高,这套双人协作越值得信赖。
  1. 成功率 SR衡量协作推理完成质量的核心指标。
    SR\text{SR}
  2. 成功任务数 N_success任务完成且结果正确的样例个数。
    NsuccessN_{\text{success}}
  3. 总任务数 N_total参与评估的全部任务个数,是成功数的分母。
    NtotalN_{\text{total}}
  4. 百分比换算乘 100% 得到直观的百分比数值,方便横向对比。
    ×100%\times 100\%

AI 应用场景

智能编程助手双人组

阶段:多 Agent 协作推理 / 应用开发

解决的问题:传统编程助手只能做单轮代码补全,遇到“实现一套带权限校验的用户模块”这类多步骤任务,容易只见树木不见森林。CAMEL 式分工让“产品经理 Agent”逐条下发模块规格,“工程师 Agent”按三段式输出实现方案,自动完成需求澄清与代码迭代。

具体案例:某团队用双 Agent 生成登录模块:产品 Agent 先明确接口与权限要求,工程师 Agent 回复“方案+进展+下一步请求”,产品 Agent 发现缺少 token 过期处理并下发补充指令,循环至验收通过,全程无需人工干预每条消息。

金融研究自动化双人组

阶段:推理链设计 / 决策支持

解决的问题:传统研报分析依赖人工把“研究目标”翻译成“执行计划”,耗时且容易遗漏。CAMEL 让研究员 Agent 负责把选题细化成具体分析任务并验收结论,数据分析师 Agent 负责分步计算与回测,形成“选题→取数→回测→结论”的自动推理链。

具体案例:研究任务“评估动量因子在 A 股的有效性”被初始化成具体指令“对近三年沪深 300 成分股计算动量因子 IC 值”。研究员 Agent 逐轮下发清洗、计算、检验指令,分析师 Agent 逐步反馈结果,直到研究员判定完成。

课程内容生成双人组

阶段:内容生产 / 多角色协作

解决的问题:单次生成课程大纲容易泛泛而谈。CAMEL 让“课程设计师 Agent”定框架、审质量,“内容创作 Agent”逐章节产出,先大纲后细化,边做边修正,最终得到结构化完整课程。

具体案例:设计师 Agent 下发“请产出第一章隐喻引入,含三个生活化案例”;创作 Agent 以三句式回复方案并请检查;设计师发现案例偏技术化,要求换成生活化场景,循环多轮后验收通过。

Python 演示

python82 行
# 简化模拟 CAMEL 角色协作推理: AI 用户拆任务, AI 助手分段求解, 验收后终止class TaskInception:    """任务初始化: 把宽泛目标改写成具体任务说明(对应 CAMEL 的 inception 阶段)"""     def __init__(self, raw_task):        self.raw_task = raw_task     def generate(self):        # 模拟大模型从原始任务中提炼出的具体任务指令        if "素数" in self.raw_task:            return "编写一个 is_prime(n) 函数并给出 10 个测试用例"        if "爬虫" in self.raw_task:            return "抓取指定页面标题并保存为 CSV 文件"        return "把原始任务拆解成三个可执行的子任务"  class AIUser:    """扮演主厨: 负责任务指令下发与完成验收, 最后发送终止信号"""     def __init__(self, specific_task):        self.task = specific_task        self.instructions = [            "先定义函数签名与边界条件",            "实现素数判断的核心逻辑",            "补充测试用例并输出完整代码",        ]        self._count = 0     def next_instruction(self):        if self._count >= len(self.instructions):            return "CAMEL_TASK_DONE"        ins = self.instructions[self._count]        self._count += 1        return ins  class AIAssistant:    """扮演帮厨: 每轮固定按 CAMEL 三句式回复"""     def __init__(self):        self.solution = ""     def reply(self, instruction):        if instruction == "CAMEL_TASK_DONE":            return ""        step_solution = "is_prime 实现: " + instruction        self.solution += step_solution + "; "        return (            "[解决方案] " + step_solution + ". "            "[给 AI 用户的话] 请检查这一方案是否符合要求. "            "[下一次请求] 请提供下一步指令."        )  def run_camel_simulation():    inception = TaskInception("判断一个整数是不是素数")    specific_task = inception.generate()    print("=== 阶段 1: 任务初始化 ===")    print("原始目标: 判断一个整数是不是素数")    print("具体任务:", specific_task)    print()    print("=== 阶段 2: 循环协作推理 ===")    user = AIUser(specific_task)    assistant = AIAssistant()    rounds = 0    while True:        instruction = user.next_instruction()        if instruction == "CAMEL_TASK_DONE":            print("AI 用户: CAMEL_TASK_DONE")            print("协作终止, 累计方案:", assistant.solution)            break        rounds += 1        print("AI 用户:", instruction)        response = assistant.reply(instruction)        print("AI 助手:", response)        print("-" * 40)    print("共进行 %d 轮协作对话" % rounds)    return True  if __name__ == "__main__":    run_camel_simulation()
目的:用规则型双 Agent 演示 CAMEL 的完整推理链——任务初始化、用户发指令、助手三句式回复、终止信号收敛。
  1. class TaskInception:对应 CAMEL 的任务初始化阶段,先把模糊目标改写成具体任务,类似把“家宴”定成菜单。
  2. return "编写一个 is_prime(n) 函数并给出 10 个测试用例"模拟大模型生成的具体任务指令,后续所有协作都围绕它展开。
  3. self.instructions = [AI 用户手里的一张“指令清单”,真实场景中由用户角色根据任务自行生成。
  4. def next_instruction(self):每轮从清单中取出一条指令下发给助手,体现用户方的推理推进。
  5. if self._count >= len(self.instructions):指令发完,说明用户判断任务已趋近完成,准备进入终止分支。
  6. return "CAMEL_TASK_DONE"发出终止信号,对应协作循环的收敛出口。
  7. def reply(self, instruction):助手的回复入口,按 CAMEL 约定组织成三句式。
  8. step_solution = "is_prime 实现: " + instruction模拟助手针对当前指令产出的方案片段,是推理链上的一环。
  9. while True:循环对话直到用户判定完成,体现推理传递链的持续接力。
  10. if instruction == "CAMEL_TASK_DONE":收到终止信号后跳出循环,协作正式结束。

常见误区

误区刚开始学 CAMEL,我以为它像 PyTorch 一样是个模型训练框架,会把两个 Agent 的对话数据拿去微调大模型。

正解CAMEL 不修改任何模型参数。它是一条“推理编排协议”:利用现成大模型,通过角色分配、任务初始化、循环对话等机制组织协作推理。类比来说,主厨和帮厨的配合方式不会改变两个人的厨艺,只改变他们怎么搭伙干活。

为何常见:名称里带“框架”,加上工作量集中在推理阶段,容易和“训练框架”混淆。

误区我以为是 AI 助手负责所有动脑,AI 用户只需要把同一个问题复制粘贴地反复问。

正解AI 用户承担的是“验收与决策”:它要根据助手的方案判断质量、提出新指令、决定是否终止。它才是协作方向的掌舵人,类似主厨尝菜后决定加盐还是上菜。缺少这一层,协作链就会失去方向。

为何常见:演示代码里用户侧的指令看起来简短,让人误以为用户角色没有推理负担。

误区我以为只要回复“任务完成”,CAMEL 就会像断电一样立刻强制停止对话。

正解CAMEL 的终止依赖双方配合:AI 用户负责发送终止信号,AI 助手要遵守约定停止推进。如果一方不配合,循环仍可能继续,因此实践中要在角色提示里写明终止规则。它是“约定信号”,不是“系统开关”。

为何常见:把协议层面的协调标记,误当成运行时的硬编码控制。

误区给模型写角色提示,我觉得一句话“你是助手”就完成角色分配了。

正解有效角色提示需要四要素:角色身份、任务背景、交互规则(谁发指令谁执行)、响应格式(三段式回复)。只有把“工牌”、工作台、交接规矩都写清楚,两个 Agent 才不会越界或跑题。

为何常见:生活里口头说一句“你来当主厨”人们就能默契配合,但模型需要显式的完整上下文约束。

误区我以为任务初始化就是把提示词改成“请你一步步思考”,属于思维链的范畴。

正解两者作用不同:任务初始化把模糊目标细化为“具体任务说明(指令+输入)”,回答“做什么”;思维链让模型分步推理,回答“怎么做”。类比:初始化是定菜单,思维链是炒菜步骤,先有菜单才有步骤可循。

为何常见:两者都发生在正式对话前、都属于提示词工程,且名称都带“化”字,极易混淆。

面试题

Q1. CAMEL 框架中两个 Agent 的固定角色是?

单选题 · easy

  • A.裁判与选手
  • B.采购与质检
  • C.教师与学生
  • D.用户与助手← 正确答案

答案:D。CAMEL 内置两个固定角色:AI 用户(发指令、验收)与 AI 助手(执行、出方案),如同后厨的主厨与帮厨。裁判、采购、教师都不是框架规定的角色,故选 D。

Q2. CAMEL 任务初始化阶段的主要目标是什么?

单选题 · easy

  • A.用新数据训练模型参数
  • B.压缩提示词的 Token 数
  • C.把模糊目标改成具体任务← 正确答案
  • D.把文字任务转成图像

答案:C。任务初始化用“知识提示”把宽泛目标重写为具体任务说明(指令+输入),好比把“一桌家宴”细化成菜单。A 是训练,B 是压缩,D 是模态转换,均不属于初始化目标。

Q3. CAMEL 中 AI 助手每轮回复默认的三项内容是什么?

单选题 · mid

  • A.摘要、结论与参考文献
  • B.标题、正文与代码注释
  • C.前提、推理与最终结论
  • D.方案、给用户的话与下一步请求← 正确答案

答案:D。CAMEL 约定助手回复按“解决方案 + 给 AI 用户的话 + 下一次请求”三段组织,保证每轮有产出、有汇报、有下一步抓手,对应帮厨递菜的“菜+报菜名+问下一道”。A、B、C 都不是 CAMEL 的消息约定。

Q4. AI 用户依据什么来发送 CAMEL_TASK_DONE?

单选题 · mid

  • A.对话轮次是否达到固定数量
  • B.模型输出概率是否低于阈值
  • C.随机抛一枚硬币的结果
  • D.对助手方案质量的验收判断← 正确答案

答案:D。AI 用户像尝菜的主厨,根据助手方案是否满足目标来决定继续或终止。固定轮次、概率阈值、抛硬币都脱离了任务本身的内容判断,故选 D。

Q5. 下列哪项能让 CAMEL 的协作推理保持可控?

单选题 · mid

  • A.允许两个 Agent 随便换角色
  • B.消息格式与角色约束← 正确答案
  • C.取消所有提示词的长度限制
  • D.每轮随机跳过用户的回复

答案:B。三段式回复格式配合角色上下文,把每轮消息锁在“用户指令→助手方案→继续/终止”的轨道上,协作才可控。换角色、取消限制、跳步都会破坏传菜口的秩序,故选 B。

Q6. 与单 Agent 直接求解相比,CAMEL 双角色协作的主要收益是什么?

单选题 · hard

  • A.让模型参数自动翻了一倍
  • B.彻底消除所有幻觉问题
  • C.目标定位与质量校验分工化← 正确答案
  • D.保证每次结果完全相同

答案:C。双角色把“定目标/验收”与“执行/产出”分开,各管一段,复杂任务更稳。参数量、幻觉、一致性属于训练或能力层面的问题,协作不会自动解决,故选 C。

Q7. “给 AI 用户的话”在三段式回复里承担什么职责?

单选题 · hard

  • A.向外部用户推送营销广告
  • B.向 AI 用户汇报状态并求确认← 正确答案
  • C.替代最终答案直接对外输出
  • D.修改 AI 用户的系统提示词

答案:B。三段式中的“沟通消息”是助手向 AI 用户汇报当前方案状态、请求确认的通道,让协作“对上话”,就像帮厨把菜端到传菜口请主厨尝味。它不面向外部用户,也不修改系统提示,故选 B。

Q8. 关于 CAMEL 的角色分配,正确的说法有?

多选题 · easy

  • A.助手角色固定不变无需推断
  • B.助手角色可由任务推断← 正确答案
  • C.用户角色负责发指令验收← 正确答案
  • D.角色信息写入系统提示词← 正确答案

答案:BCD。CAMEL 中助手角色从具体任务推断而来,用户角色负责下发指令与验收,两者通过角色提示固化进系统消息。A 说反了——固定的是“用户/助手”这两个岗位,助手的具体身份要按任务现写工牌。

Q9. CAMEL 协作推理循环中可能出现的环节包括?

多选题 · mid

  • A.AI 用户下发新的任务指令← 正确答案
  • B.AI 助手按三句式格式回复← 正确答案
  • C.双方互相修改对方的系统提示词
  • D.用户判定完成后终止循环← 正确答案

答案:ABD。循环典型环节是“用户发指令→助手三句式回复→用户验收→继续或终止”。系统提示词在开局时就已设定,循环过程中并不互相修改,C 不属于设计内的环节。

Q10. 关于 CAMEL 与思维链的关系,正确的理解有?

多选题 · hard

  • A.角色提示词中可要求分步推理← 正确答案
  • B.多轮消息本身构成协作推理链← 正确答案
  • C.跨轮递进帮助答案走向深入← 正确答案
  • D.思维链只能出现在系统提示中

答案:ABC。角色提示可以内嵌“先思考步骤再作答”的要求;指令-方案-反馈的多轮互动本身构成一条跨轮协作推理链,且能逐轮细化答案。思维链并不局限于系统提示,D 说法过于绝对,故选 ABC。