周末走进一家小餐馆，你只需对服务员说一句“来杯热茶”。这句话到了后厨，却要变成一连串精确的动作：拿杯子、找茶包、烧水、冲泡、端上桌。如果换成一台机器人，它面临的正是同样的问题——听得懂“给我倒杯热茶”，却不知道先做什么、再做什么。在具身大模型与 VLA 的架构里，大语言模型（LLM）就扮演着那位“总厨师长”：它不亲自掌勺，而是把顾客的一句话翻译成一张可执行的“操作卡”，指挥后厨各司其职。这就是 LLM+机器人任务规划。本篇文章会跟随这间“智能厨房”一路走下去，看看提示词设计、思维链推理、代码式规划、技能库对接与执行反馈闭环如何环环相扣，把一句人话变成机器人的行动方案。

岗位关联

掌握 LLM 任务规划，你就掌握了让机器人“听懂人话并干活”的核心工程能力。这是具身智能从演示走向产品化的分水岭，也是机器人算法工程师在 LLM 时代的必修课。

目录
  1. 可视化演示
  2. 规划任务本质
  3. 提示词设计
  4. 思维链推理
  5. 代码式规划
  6. 技能库对接
  7. 执行反馈闭环
  8. 挑战与发展
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

通过任务分解链、技能库接地评分与VLA模型架构三个模式，展示大语言模型如何将自然语言目标分解为机器人可执行动作序列。

本节配有交互动效（进入视口后自动加载，约 3KB）。

'+captions.decomp+'

规划任务本质

所有菜品都是从“拆单”开始的。客人的一句话是模糊的、整体的，后厨的执行却是具体的、线性的：先拿杯子、再放茶包、然后注水。任务规划要做的，恰恰就是这道“拆单”工序——把自然语言目标翻译成一串有序的可执行子任务。在具身大模型与 VLA 的框架里，这通常由大语言模型负责。它不碰电机、不看像素，只回答一个问题：“为了达成目标，机器人应该按什么顺序做什么？”

从概念上讲，任务规划位于“感知—规划—控制”链条的正中间。感知模块告诉机器人“环境里有什么”，规划模块决定“接下来干什么”，控制模块（如 VLA 策略）负责“具体怎么动”。LLM 能胜任规划者，是因为它在大规模文本上习得了丰富的世界知识：它知道“泡茶要先烧水、水要烧开才能泡”，这种常识正是传统手工规则规划器最难以编写、也最难维护的部分。

形式化地看，LLM 任务规划是一个条件概率最大化问题：在所有可行规划中，选出在给定目标和技能库条件下最有可能的那一个。

在智能厨房里，“总厨师长”LLM 拿到需求后并不直接下锅，而是先写出这份“拆单”。它输出的不是火候参数，而是“先做什么、后做什么”的决策。理解了这一点，后面所有工程手段——提示词、思维链、代码式输出——都围绕一个目标展开：让这位总厨师长的“拆单”更聪明、更可靠。

π∗=arg⁡max⁡π∈Π P(π∣G, S)\displaystyle \pi^{*} = \arg\max_{\pi \in \Pi} \ P\bigl(\pi \mid G,\ \mathcal{S}\bigr)
意思是：机器人团队在“顾客需求 G”和“厨房现有技能 S”的约束下，挑选一个胜算最高的执行方案 π*。
  1. 候选规划空间 Π所有可能的子任务序列构成的集合，相当于后厨所有可能的做菜流程组合。
    Π={π1, π2, …, πk}\Pi = \{\pi_1,\ \pi_2,\ \dots,\ \pi_k\}
  2. 规划 π 本身一个具体的子任务序列，例如“拿杯→放茶包→注水→端茶”。
    π=[s1, s2, …, sn]\pi = [s_1,\ s_2,\ \dots,\ s_n]
  3. 条件 G 与 S规划必须同时满足用户的目标描述和机器人自身的能力边界，缺一不可。
    P(π∣G, S)P(\pi \mid G,\ \mathcal{S})
  4. argmax 求最优在候选空间中搜寻使条件概率最大的规划，即最“合情理”的做法。
    π∗=arg⁡max⁡π∈ΠP(π∣G, S)\pi^{*} = \arg\max_{\pi \in \Pi} P(\pi \mid G,\ \mathcal{S})

提示词设计

主厨再聪明，也怕顾客语焉不详。“来杯热茶”和“用龙井、85 度水、不加糖”给出的自由度完全不同。对 LLM 来说，提示词就是写给主厨的那张“工单”：工单写得清楚，规划才靠谱；工单写得含糊，再聪明的主厨也只能瞎猜。

Prompt 设计有三个核心杠杆。第一是角色设定（system prompt），例如“你是一名家用机器人规划器，只能输出 JSON 格式的子任务列表”，这相当于先告诉主厨“今天你的岗位是配菜，不是收银”，让模型进入专业状态。第二是示例引导（few-shot），给一两个“目标→规划”的成对范例，模型就会模仿其格式、粒度和风格。第三是约束注入，把技能库清单和环境物体列表直接写进工单，告诉模型“后厨只有这些师傅和食材，别乱编”。

数学上，提示词本质上是改变了模型的输出分布——同样是那个模型，换一张工单，输出的规划概率分布就完全不同。

所以，提示词工程不是“玄学”，而是有明确数学语义的系统工程。老主厨拿到工单后会按图索骥，模型拿到好的 prompt 也会收敛到高质量的规划空间。工单上写清“有哪些师傅（技能）、什么食材（物体）、按什么格式汇报（输出约束）”，这份规划就已经成功了一半。

π∗=arg⁡max⁡π Pθ(π∣prompt(G, S))\displaystyle \pi^{*} = \arg\max_{\pi} \ P_{\theta}\Bigl(\pi \mid \mathrm{prompt}\bigl(G,\ \mathcal{S}\bigr)\Bigr)
提示词不是“装饰品”，而是直接操纵模型输出分布的旋钮。写好 prompt，等于替主厨圈定了搜索范围，他再离谱也不会跑出厨房。
  1. 工单构造器 prompt把目标 G 和技能库 S 组装成一段结构化指令文本，类似于把客人要求写在点菜单上。
    prompt(G, S)=[角色; 示例; 技能清单; 目标]\mathrm{prompt}(G,\ \mathcal{S}) = [\text{角色};\ \text{示例};\ \text{技能清单};\ \text{目标}]
  2. 模型参数 θLLM 的内部权重，决定了同一张工单下它更倾向输出什么规划。
    Pθ(⋅∣prompt)P_{\theta}(\cdot \mid \mathrm{prompt})
  3. 最大化输出概率让模型“更倾向于”生成某个规划，即概率最高的那一个被选中执行。
    arg⁡max⁡πPθ(π∣prompt)\arg\max_{\pi} P_{\theta}(\pi \mid \mathrm{prompt})

思维链推理

有经验的师傅接到复杂订单时，会一边盘算一边念叨：“冰箱里还有茶包吗？哦有。那先烧水，再找杯子……”这种“把思考过程说出来”的习惯，在 LLM 领域有个名字：思维链（Chain-of-Thought，CoT）。总厨师长不需要闷头报结论，而是把决策链一条条摆在桌面上。

对于任务规划而言，CoT 的价值在于把隐式推理显式化。模型先根据目标推理当前环境状态，再逐步推导下一步动作，而不是直接蹦出最终答案。每一步推理都以前面的步骤为条件——“先有杯子，才能放茶包；先烧水，才能注水”。这样一来，中间任何一步出错都能被较早暴露，规划器的逻辑也变得更可检查、可调试。

从概率角度看，思维链就是把“整个规划发生的概率”分解成“一步一步接着想”的条件概率乘积。

在智能厨房里，思维链让“总厨师长”把自言自语变成流程：先确认食材、再设计工序、最后检查漏洞。相比“一口报出十个步骤”的激进做法，边走边想虽然慢一点，却大大降低了漏步骤、乱顺序的概率。

P(s1, s2, …, sn∣g)=∏t=1nP(st∣g, s1, …, st−1)\displaystyle P(s_1,\ s_2,\ \dots,\ s_n \mid g) = \prod_{t=1}^{n} P\bigl(s_t \mid g,\ s_1,\ \dots,\ s_{t-1}\bigr)
整个规划的概率 = 一步步接着想的概率连乘。每一步都建立在前面的所有步骤之上——这就是思维链背后的数学直觉。
  1. 子任务 s_t规划中第 t 步要执行的动作，例如“拿杯子”。
    st∈{s1, s2, …, sn}s_t \in \{s_1,\ s_2,\ \dots,\ s_n\}
  2. 条件依赖第 t 步的决策依赖目标 g 以及之前所有步骤的结果，不允许跳步。
    P(st∣g, s1, …, st−1)P\bigl(s_t \mid g,\ s_1,\ \dots,\ s_{t-1}\bigr)
  3. 乘积法则联合概率通过链式法则拆成条件概率的连乘，模型逐字生成其实就是逐步采样。
    ∏t=1nP(st∣g, s<t)\prod_{t=1}^{n} P(s_t \mid g,\ s_{<t})

代码式规划

后厨里最值钱的不是散文式菜谱，而是“标准操作卡”：第几步、用什么料、多少量、什么火候，每条都精确到可执行。代码式规划的思路完全一致——让 LLM 输出的不是一段自然语言描述，而是一段 Python 风格的函数调用代码。这就是代码即规划（Code as Plan）。

为什么代码比自然语言更好使？第一，代码天然结构化，一条语句就是一个子任务，语句顺序即执行顺序。第二，代码支持参数传递，grasp('cup') 把物体作为参数打包，比文本“然后去拿那个杯子”更明确、更不易产生歧义。第三，代码可以被解释器逐条安全执行，配合白名单校验，天然适合对接机器人的技能库——总厨师长写下的操作卡，切墩师傅直接照着执行就行。

形式化地，代码式规划就是让 LLM 在函数签名空间的约束下，生成概率最高的代码序列。

在智能厨房里，代码式规划等于让总厨师长不写“小作文”，改画“流程图”。机器人的每个动作都对应一行命令，有问题就删掉这一行，需要复用就整段复制。这种可读、可达、可执行的特质，让 LLM 规划从“看个热闹”真正变成“能跑起来”。

C∗=arg⁡max⁡C Pθ(C∣G, F)\displaystyle C^{*} = \arg\max_{C} \ P_{\theta}\Bigl(C \mid G,\ \mathcal{F}\Bigr)
C 是代码形式的规划，F 是技能函数签名集合。代码是“菜谱的机器可读版本”：人看得懂，机器人也执行得动。
  1. 代码规划 C由技能调用语句组成的序列，如 move('table') 后接 grasp('cup')。
    C=[call1, call2, …, calln]C = [\text{call}_1,\ \text{call}_2,\ \dots,\ \text{call}_n]
  2. 函数签名集 F每个技能的签名形式，例如 grasp(obj)、place(obj, loc)。
    F={f1, f2, …, fm}\mathcal{F} = \{ f_1,\ f_2,\ \dots,\ f_m \}
  3. 目标与签名共同约束生成代码既要服务于目标 G，又必须符合 F 中的签名规范。
    Pθ(C∣G, F)P_{\theta}(C \mid G,\ \mathcal{F})
  4. argmax 选择在所有合法代码输出中挑概率最高的那段作为最终规划。
    C∗=arg⁡max⁡CPθ(C∣G, F)C^{*} = \arg\max_{C} P_{\theta}(C \mid G,\ \mathcal{F})

技能库对接

总厨师长不会亲自切每一根葱，他喊一声“切墩的，萝卜切丝”，自有专人执行。机器人的“后厨师傅”就是技能库（Skill Library）——一组预先实现好的原子技能，如 grasp()、move()、place()、pour()。LLM 的规划工作说到底，就是决定“请哪位师傅、做什么、传什么参数”。

技能库对接有三层关键设计。第一层是 API 约束：prompt 中明确告知模型所有可用技能及其签名，禁止输出库以外的调用——相当于在工单上写明“后厨只有这几位师傅”。第二层是技能检索：当技能数量膨胀到上百个时，先用向量相似度把与当前子任务最相关的候选技能筛出来，再交给 LLM 选择，避免大海捞针。第三层是参数绑定：将场景中感知到的物体名（如 'cup'）与技能参数一一对应，确保调用合法、物体存在。

技能检索这一层可以用相似度函数形式化描述。

技能库就是这间智能厨房的“师傅花名册”。没有它，总厨师长再聪明也只能纸上谈兵；有了它，LLM 只需要做选择题——从花名册里点将，把自然语言目标翻译成师傅们听得懂的行话。

fi∗=arg⁡max⁡fi∈F sim(Emb(ti), Emb(desc(fi)))\displaystyle f_i^{*} = \arg\max_{f_i \in \mathcal{F}} \ \mathrm{sim}\Bigl( \mathrm{Emb}(t_i),\ \mathrm{Emb}\bigl(\mathrm{desc}(f_i)\bigr) \Bigr)
把当前子任务的语义与每个技能的文字描述做相似度匹配，找到最“对味”的那位师傅。
  1. 子任务嵌入将第 i 个子任务文本编码成向量，代表“我想让师傅做的事”。
    Emb(ti)\mathrm{Emb}(t_i)
  2. 技能描述嵌入将每个技能的功能描述编码成同一空间中的向量，代表“这位师傅擅长的事”。
    Emb(desc(fi))\mathrm{Emb}(\mathrm{desc}(f_i))
  3. 相似度匹配用余弦相似度等函数衡量两者语义契合程度，得分高说明“对症”。
    sim(Emb(ti), Emb(desc(fi)))\mathrm{sim}\bigl(\mathrm{Emb}(t_i),\ \mathrm{Emb}(\mathrm{desc}(f_i))\bigr)
  4. argmax 选技能从技能库中挑出与子任务最匹配的那个技能作为执行原语。
    fi∗=arg⁡max⁡fi∈Fsim(⋅, ⋅)f_i^{*} = \arg\max_{f_i \in \mathcal{F}} \mathrm{sim}(\cdot,\ \cdot)

执行反馈闭环

菜出锅前，主厨总要尝一口：“咸了加水，生了回锅。”这个“尝与改”的过程，在机器人规划里叫执行反馈闭环。LLM 规划不是一次性买卖——机器人执行子任务时会不断产生新的观测，一旦某个技能调用失败，规划器就要根据失败信息重新规划后续步骤，而不是硬着头皮往下走。

典型的闭环流程是：执行监控（monitor）捕捉异常信号，比如“抓取失败了，手里没有杯子”；把失败描述、当前环境状态以及已执行步骤一起反馈给 LLM；LLM 生成修正后的剩余规划；机器人继续执行。如此循环往复，系统就从“静态规划一次跑到底”进化为“动态自适应地边看边做”。

下一轮规划可以看作一次“基于反馈的条件生成”。

智能厨房里最真实的场景恰恰如此：茶包可能被用完了，热水壶可能放错了位置。有了执行反馈闭环，总厨师长不再是“拍脑袋定菜单”，而是每出一道菜都尝一口，根据客人的表情微调配方——这样的机器人，才是真正能走出实验室、走进真实世界的机器人。

πk+1=LLM(G, S, obsk, failk)\displaystyle \pi_{k+1} = \mathrm{LLM}\Bigl(G,\ \mathcal{S},\ \mathrm{obs}_k,\ \mathrm{fail}_k\Bigr)
意思是：主厨听到“菜有点咸”的反馈后，拿回目标、技能、现状和失败信息，重新设计后半段做法。
  1. 当前观测 obs_k第 k 轮执行后机器人看到的实时状态，例如“杯子不在茶几上”。
    obsk\mathrm{obs}_k
  2. 失败信息 fail_k本轮执行中具体在哪个技能、哪个参数上出了错。
    failk\mathrm{fail}_k
  3. LLM 重规划把目标、技能库、观测、失败信息一起作为输入，重新生成剩余规划。
    LLM(G, S, obsk, failk)\mathrm{LLM}\bigl(G,\ \mathcal{S},\ \mathrm{obs}_k,\ \mathrm{fail}_k\bigr)
  4. 迭代更新得到下一轮的规划，进入新一轮执行，形成闭环。
    πk+1→执行→obsk+1, failk+1→πk+2\pi_{k+1} \to \text{执行} \to \mathrm{obs}_{k+1},\ \mathrm{fail}_{k+1} \to \pi_{k+2}

挑战与发展

再厉害的厨师也会失手：看错食材、误判火候、被突发的厨房混乱打乱节奏。LLM 规划器同样面临三大挑战。第一是幻觉：模型可能编造出技能库里根本不存在的技能，或幻想环境里没有的物体——相当于主厨凭空喊了一位并不存在的师傅。第二是泛化：换一个“新厨房”（新环境、新的物体组合），规划质量可能断崖式下跌。第三是多模态融合：真实机器人需要把视觉、语言、动作对齐，纯文本规划难以覆盖稠密的几何与物理约束。

应对方向也在快速演进。检索增强（RAG）让模型在规划时实时查阅技能文档，降低幻觉；代码沙箱与白名单机制把不可信输出拦截在执行之前；分层架构让 LLM 负责高层规划、VLA 策略负责低层动作，各司其职；多模态大模型则直接输入图像，让规划器“看得见厨房”再下单。

评判一个规划器的长期表现，可以看它对所有可能规划的期望回报——既要规划合理，也要执行成功率高。

回到这间智能厨房：一个可靠的“总厨师长”不是从不犯错，而是错误可控、可回退、可改进。白名单拦住幻觉，反馈闭环兜住失败，多模态让规划“看见”真实世界——当这些机制组合在一起，LLM 才从一位“话痨主厨”成长为真正能独当一面的机器人总指挥。

E[R]=∑π∈ΠP(π∣G)×R(π)\displaystyle \mathbb{E}[R] = \sum_{\pi \in \Pi} P(\pi \mid G) \times R(\pi)
好规划器不是“偶尔灵光一现”，而是整体期望回报高：大概率出好规划，小概率出坏规划，但坏规划也能被反馈闭环兜住。
  1. 回报函数 R(π)执行完规划 π 后得到的效果评分，任务完成度越高分值越大。
    R(π)∈[0, 1]R(\pi) \in [0,\ 1]
  2. 规划概率 P(π|G)给定目标 G，模型生成规划 π 的概率，反映模型“多常想出这个方案”。
    P(π∣G)P(\pi \mid G)
  3. 期望回报把所有规划按概率加权求和，得到该规划器的平均表现水平。
    E[R]=∑πP(π∣G)×R(π)\mathbb{E}[R] = \sum_{\pi} P(\pi \mid G) \times R(\pi)

AI 应用场景

家用服务机器人——“一句话下单，机器人跑腿”

阶段：推理与规划（模型部署后的在线规划）

解决的问题：传统方案用行为树或状态机手写每种任务的流程，遇到“帮我把阳台的拖鞋拿来”这类新指令就要重新编程。LLM 规划器把自然语言直接变成流程，零代码适配新任务，大大降低定制成本。

具体案例：用户说“我回来前把客厅收拾一下”，机器人把指令交给 LLM，LLM 结合家居技能库生成“搬走茶几上的杯子→摆正沙发靠垫→用吸尘器吸地毯”的子任务序列，再经技能库逐条执行；执行中发现杯子不在茶几上，触发重规划自动跳过该步。整个过程用户只需说一句话。

仓储物流机械臂分拣——代码式规划上线

阶段：代码式规划 + 技能库对接（在线推理执行）

解决的问题：传统分拣依赖人工编排可编程逻辑控制器的流程，商品品类一变就要停机改程序。代码式规划让 LLM 直接生成技能调用序列，配合白名单执行器快速切换品类，将换线时间从数小时压缩到分钟级。

具体案例：管理员说“把红色包装盒放到 3 号传送带”，LLM 生成 scan('red_box') → grasp('red_box') → move('belt_3') → place('red_box', 'belt_3') 的代码规划，白名单执行器逐行校验后交给机械臂执行，全程无需人工编写逻辑。

具身智能仿真数据生成——VLA 训练的“任务剧本工厂”

阶段：数据准备（VLA 模型训练前置环节）

解决的问题：VLA 训练需要海量“指令-轨迹”数据，人工标注成本极高。用 LLM 自动为仿真环境生成多样化的任务规划，再对接技能库驱动虚拟机器人执行，能低成本批量产出带标签的演示数据。

具体案例：在 Isaac/Habitat 仿真环境中，研究员用 LLM 为同一场景批量生成“把苹果放进冰箱”“打开抽屉放入纸巾”等任务规划，虚拟机器人按规划执行并采集视觉-动作轨迹，用于后续 VLA 模型的微调与评测。

Python 演示

python111 行
import re  class SkillLibrary:    """机器人技能库：每个技能函数代表一个可执行原语"""     def __init__(self):        self.skills = {            "grasp": "抓取指定物体",            "move": "移动到指定位置",            "place": "放置物体到指定位置",            "pour": "将液体倒入目标容器",            "scan": "扫描并返回物体坐标"        }        self.grasp_count = 0        self.move_count = 0     def grasp(self, obj):        self.grasp_count += 1        return "[执行] 抓取 {} 完成".format(obj)     def move(self, pose):        self.move_count += 1        return "[执行] 移动到 {} 完成".format(pose)     def place(self, obj, loc):        return "[执行] 将 {} 放到 {} 完成".format(obj, loc)     def pour(self, obj, target):        return "[执行] 将 {} 倒入 {} 完成".format(obj, target)     def scan(self, env):        return "[执行] 扫描 {}，发现杯子、茶包、热水壶".format(env)  class LLMPlanner:    """模拟大语言模型规划器：自然语言目标 -> 代码式规划"""     def __init__(self, skill_lib):        self.skill_lib = skill_lib        self.available_skills = sorted(skill_lib.skills.keys())        # 实际项目中这里应调用真实 LLM API，此处用模板模拟返回        self.plan_templates = {            "帮我泡一杯茶": [                "scan('厨房台面')",                "grasp('杯子')",                "place('杯子', '吧台')",                "grasp('茶包')",                "place('茶包', '杯子')",                "pour('热水壶', '杯子')"            ],            "把快递搬到门口": [                "move('玄关')",                "grasp('快递箱')",                "move('门口')",                "place('快递箱', '门外')"            ]        }     def plan(self, goal):        if goal in self.plan_templates:            return "\n".join(self.plan_templates[goal])        return "# 未找到匹配模板，请补充更多示例"  class CodePlanExecutor:    """安全执行器：白名单校验 LLM 生成的代码，只允许调用技能库函数"""     def __init__(self, skill_lib):        self.skill_lib = skill_lib     def run(self, code_plan):        allowed = {            "grasp": self.skill_lib.grasp,            "move": self.skill_lib.move,            "place": self.skill_lib.place,            "pour": self.skill_lib.pour,            "scan": self.skill_lib.scan        }        reports = []        for line in code_plan.splitlines():            line = line.strip()            if not line or line.startswith("#"):                continue            m = re.match(r"(\w+)\((.*)\)$", line)            if not m:                raise ValueError("非法语句，不是技能调用: " + line)            name, args_str = m.group(1), m.group(2)            if name not in allowed:                raise ValueError("禁止调用未注册技能: " + name)            args = [a.strip().strip("'\"") for a in args_str.split(",")]            reports.append(allowed[name](*args))        return reports  def main():    lib = SkillLibrary()    planner = LLMPlanner(lib)    goal = "帮我泡一杯茶"    print("【自然语言目标】", goal)    code_plan = planner.plan(goal)    print("【LLM 生成的代码式规划】")    print(code_plan)    executor = CodePlanExecutor(lib)    print("【白名单执行器逐条运行】")    for report in executor.run(code_plan):        print(report)  if __name__ == "__main__":    main()
目的：演示“自然语言目标 → LLM 代码式规划 → 白名单执行器 → 技能库调用”的完整链路，这是 LLM+机器人任务规划的最小可运行闭环。
  1. class SkillLibrary:技能库即“后厨师傅”集合，每个方法代表一个原子技能。
  2. self.skills = {...}技能注册表：LLM 只能调用注册过的技能，这是第一道安全边界。
  3. self.grasp_count += 1记录技能调用次数，便于后续做执行监控与统计。
  4. class LLMPlanner:模拟 LLM 规划器：输入自然语言目标，输出代码式规划。
  5. return "\n".join(self.plan_templates[goal])LLM 输出的“操作卡”是一段多行代码，每行一个技能调用。
  6. class CodePlanExecutor:安全执行器，只负责运行“白名单内”的代码。
  7. m = re.match(r"(\w+)\((.*)\)$", line)逐行解析函数调用语法，拒绝非技能语句。
  8. if name not in allowed: raise ValueError(...)白名单校验，拦住幻觉出来的技能。
  9. args = [a.strip().strip("'\"") ...]解析并清洗参数，把物体名绑定到技能参数上。
  10. reports.append(allowed[name](*args))真正调用技能库方法，收集逐条执行报告。
  11. executor.run(code_plan)执行整个规划序列，对应正文中的“代码式规划 + 安全执行”。

常见误区

误区我以为让 LLM 输出一串电机角度或者关节力矩，机器人就能直接动起来，结果一跑就乱套。它不是应该什么都会吗？

正解LLM 是“总厨师长”而不是“掌勺师傅”。它输出的是高层子任务序列，比如“拿杯子、放茶包”；底层运动由 VLA 策略和运动控制器执行。两层通过技能库解耦：LLM 负责决策，控制器负责出力，直接让 LLM 输出原始控制量既不可靠也不安全。

为何常见：短视频里“AI 控制机器人”常被演绎成端到端一步到位，让人误以为大模型能直接接管电机，忽视了规划与控制之间的清晰分工。

误区我把整个环境的每个细节都塞进 prompt，想让模型“全知全能”，结果它反而规划得更差，甚至开始胡言乱语。

正解上下文窗口是有限的，无关信息会稀释关键指令的注意力。好 prompt 是“有效的工单”：角色设定 + 少量示例 + 技能清单 + 目标本身，控制信息密度、突出约束，模型才能抓住重点。信息过载和缺失一样有害。

为何常见：直觉上“信息越多越好”，忽略了 Transformer 的注意力机制会把权重分散到大量无关 token 上，关键指令反而被淹没。

误区规划器既然输出的是代码，那直接运行不就好了？代码不报错，就说明没问题。

正解直接运行等于把“幻觉”直接变成“事故”。LLM 可能编造不存在的技能、传错参数，代码语法上毫无问题但物理上不可行。必须经过白名单执行器：只允许调用已注册技能、只接受固定参数格式，从机制上拦截不可信代码，而不是赌模型这次没犯错。

为何常见：LLM 输出看起来合情合理，语法检查也通过，很容易让人放松安全警惕，忽略了“合理”与“可安全执行”之间的鸿沟。

误区大模型什么都知道，告诉它目标，它自己就能规划出一切动作，还要技能库做什么？后厨师傅根本多余。

正解LLM 没有“身体”，不知道你的机械臂有几个关节、夹爪能抓多重的东西。技能库既是可执行原语的供给方，也是天然的校验边界——“只能做这些事”恰恰保证规划不飘。没有技能库，LLM 的规划就是无根之木，无法落到底层执行。

为何常见：LLM 强大的文本能力让人误以为它“全能”，忽略了它既没有传感器，也没有物理约束，必须依赖技能库这座“桥梁”才能连接真实世界。

面试题

Q1. 在 LLM+机器人任务规划中，大语言模型主要承担什么角色？

单选题 · easy

  • A.直接驱动电机转动
  • B.高层推理与任务分解← 正确答案
  • C.替换所有视觉相机
  • D.焊接机械臂结构件

答案：B。LLM 是“总厨师长”，负责把自然语言目标分解成有序子任务序列，即高层推理与任务分解。它不直接控制电机，也不替代相机等感知硬件，更不涉及机械结构制造。

Q2. 任务规划环节输出的核心产物是什么？

单选题 · easy

  • A.电机的电流大小
  • B.相机曝光参数值
  • C.有序子任务序列← 正确答案
  • D.外壳喷涂的颜色

答案：C。任务规划输出的是一连串按顺序排列的可执行子任务，相当于“拿杯→放茶包→注水”的操作卡。电流、曝光等属于底层控制与感知参数，不是规划层的输出。

Q3. 提示词中设置“角色”的主要目的是什么？

单选题 · mid

  • A.让输出更加冗余啰嗦
  • B.限定模型视角与职责← 正确答案
  • C.增加训练数据总量
  • D.让模型运行更加快速

答案：B。角色设定相当于告诉主厨“今天的岗位是配菜”——把 LLM 的视角限定到“机器人规划器”上，引导它用专业格式输出规划。它不改变训练数据，也不影响推理速度，更不是为了凑字数。

Q4. 思维链推理在任务规划中的作用包括哪些？

多选题 · mid

  • A.显式生成中间推理步骤← 正确答案
  • B.帮助追踪执行状态变化← 正确答案
  • C.使中间逻辑可以被检查← 正确答案
  • D.完全消除所有失败风险

答案：ABC。思维链把“先烧水再泡茶”这类中间步骤显式写出来，每一步都基于前一步，天然支持状态追踪，也让工程师能检查逻辑断点。但它只是降低错误率，不能“完全消除失败”——执行反馈闭环依然必不可少。

Q5. 代码式规划最核心的优势是什么？

单选题 · mid

  • A.文本更加简洁易读
  • B.完全不需要安全校验
  • C.结构化且支持传参复用← 正确答案
  • D.适合所有非结构化任务

答案：C。代码式规划把子任务写成函数调用序列，天然结构化、可传参数、可复用，比如 grasp('cup') 可以直接换参数变成 grasp('box')。它依然需要安全校验，也不适合所有任务。

Q6. 技能库对接时，下列哪项做法最安全？

单选题 · hard

  • A.允许调用任意系统函数
  • B.使用 eval 直接执行代码
  • C.白名单过滤后调用技能← 正确答案
  • D.关闭所有错误检测机制

答案：C。白名单过滤是安全执行的核心：LLM 生成的代码只能调用已注册的 grasp/move/place 等技能，其他一律拒绝。任意系统函数、eval、关闭错误检测都是在给幻觉代码开大门，极其危险。

Q7. 执行反馈闭环中“重规划”的输入包括哪些？

单选题 · hard

  • A.只有历史随机数据
  • B.仅初始自然语言目标
  • C.预先写死的固定规划
  • D.失败描述与当前观测← 正确答案

答案：D。重规划像主厨尝菜后调整配方，需要把目标 G、技能库 S、当前观测 obs 和失败信息 fail 一起喂给 LLM。只靠初始目标或固定规划无法感知执行错误，随机数据更是毫无意义。

Q8. LLM 任务规划中最典型的幻觉表现是什么？

单选题 · mid

  • A.编造不存在的技能或物体← 正确答案
  • B.输出速度变得极其缓慢
  • C.消耗的内存大幅增加
  • D.训练损失降到最低点

答案：A。幻觉是指模型“一本正经地胡说八道”：编出一个技能库里没有的技能，或者幻想环境里不存在的物体——相当于主厨喊了一位根本没入职的师傅。速度、内存、训练损失都不是幻觉的定义。

Q9. 设计任务规划提示词时常用的技巧有哪些？

多选题 · easy

  • A.设定主厨角色与职责← 正确答案
  • B.提供少量规划示例← 正确答案
  • C.列出可用的技能清单← 正确答案
  • D.直接运行任意生成的代码

答案：ABC。角色设定让模型入戏，示例引导模仿格式，技能清单约束搜索空间——三者是提示词设计的三大杠杆。直接运行生成的代码属于执行阶段的操作，且必须经过白名单校验，不是提示词技巧。

Q10. 当前 LLM 任务规划面临的主要挑战有哪些？

多选题 · hard

  • A.幻觉导致子任务不可执行← 正确答案
  • B.对陌生环境的泛化能力弱← 正确答案
  • C.多模态信息融合尚不成熟← 正确答案
  • D.规划过程完全不消耗算力

答案：ABC。幻觉会编造不存在的能力或物体；换一个新环境时规划质量会明显下滑；纯文本规划难以覆盖视觉与物理约束，多模态融合仍在发展。至于“不消耗算力”恰恰相反，LLM 推理是典型的算力密集型任务。