06.多轮 Agent 在动态意图识别环境下的生命周期管理
多轮 Agent 在动态意图识别环境下的生命周期管理

1. 引言
在构建基于 AI 的对话系统时,我们常常需要将现有的服务能力封装为 AI 对话的 tool,或者将多个服务能力打包为一个 agent 供 AI 对话交互使用。当已有服务能力较多时,基于用户交互的意图识别 + 动态注册服务能力成为一种常见的架构选择。
然而,这种架构在面对多轮引导式信息收集场景时,会出现一个核心问题:用户输入的内容可能因意图识别与当前 agent 无关联,导致该 agent 未被注册,从而造成整个多轮对话流程的意外中断。
本文将深入探讨这一问题的本质,分析多种可行的解决方案,并对各方案进行对比,帮助你在实际项目中做出合适的架构决策。
2. 问题背景
2.1 典型架构模式
在现代 AI 对话系统中,常见的架构模式如下:
用户输入 → 意图识别模块 → 动态注册匹配的 Tool/Agent → LLM 调用 → 返回结果
这种模式的优势在于:
- 按需加载:只注册与当前意图相关的服务,减少 token 消耗
- 扩展性强:新增服务能力只需注册即可,无需修改核心逻辑
- 资源高效:避免将所有 tool 一次性注入 prompt

2.2 多轮 Agent 的特殊性
多轮引导式 agent 的典型特征是:
- 需要跨多轮对话维持状态
- 每轮对话中,agent 会向用户提出问题,收集特定信息
- 用户回答可能偏离当前 agent 的意图范畴
- 信息收集完成后,agent 才会执行最终的服务调用
例如,一个"预订会议室"的 agent 可能需要多轮对话来收集:
- 会议时间
- 参会人数
- 设备需求
- 特殊要求
在这个过程中,用户可能会突然问:"今天天气怎么样?"——这显然与会议室预订无关。
3. 问题说明
3.1 核心矛盾
问题的核心矛盾在于:
| 维度 | 动态意图识别 | 多轮 Agent |
|---|---|---|
| 设计目标 | 每轮独立识别最相关意图 | 维持跨轮次的对话状态 |
| 注册策略 | 仅注册匹配当前意图的服务 | 需要持续注册直至任务完成 |
| 状态管理 | 无状态或弱状态 | 强状态依赖 |
当用户输入偏离当前 agent 的意图范畴时,意图识别模块可能:
- 完全忽略当前活跃的 agent
- 注册其他更匹配的 tool/agent
- 导致当前 agent 失去执行机会

3.2 具体表现
用户:我想预订一个会议室
系统:[意图识别:meeting_room_booking] → 注册 booking_agent
booking_agent:好的,请问您需要什么时间?
用户:下午三点
系统:[意图识别:meeting_room_booking] → 注册 booking_agent
booking_agent:请问参会人数是多少?
用户:对了,帮我查一下明天的天气
系统:[意图识别:weather_query] → 注册 weather_tool,❌ 未注册 booking_agent
[booking_agent 中断,状态丢失]
weather_tool:明天天气晴朗...
用户:5个人
系统:[意图识别:???] → 无法匹配到 booking_agent
[对话流程断裂]
3.3 影响范围
这个问题会导致:
- 用户体验下降:需要重新开始整个流程
- 信息丢失:已收集的信息无法保留
- 信任度降低:用户认为系统"记不住"之前的对话
- 转化率下降:对于业务场景(如预订、购买),直接导致转化失败
4. 解决方案

方案一:Agent 会话锁定(Session Locking)
核心思想
当多轮 agent 被激活后,在会话层面设置锁定标志,在锁定期间强制优先注册该 agent,即使用户输入与其他意图匹配,也不释放焦点。
为什么需要这个方案
在动态意图识别架构中,每一轮对话都是"从零开始"的意图匹配。这意味着系统天然不具备"记忆"——它不知道上一轮正在执行哪个 agent。对于单轮查询(如天气、翻译),这完全没问题;但对于多轮信息收集场景,这种无状态特性就是致命的。
会话锁定是最直接的解决思路:既然系统记不住,那我就强制它记住。通过一个显式的锁定标志,告诉全局路由"当前有一个正在进行的多轮任务,不要打断它"。
实现方式
interface SessionState {
activeAgent: string | null;
lockUntil: number; // 锁定过期时间戳
collectedData: Record<string, any>;
requiredFields: string[];
currentField: string;
}
class SessionManager {
private sessions: Map<string, SessionState> = new Map();
async resolveAgent(input: string, sessionId: string): Promise<string[]> {
const session = this.sessions.get(sessionId);
// 检查是否有活跃的锁定 agent
if (session?.activeAgent && session.lockUntil > Date.now()) {
// 检查是否完成所有必填字段
if (Object.keys(session.collectedData).length < session.requiredFields.length) {
return [session.activeAgent]; // 强制返回当前 agent
}
}
// 否则执行正常的意图识别
return this.intentRecognition(input);
}
// 用户输入明显切换意图时,允许解锁
allowUnlock(sessionId: string, confidence: number): boolean {
const session = this.sessions.get(sessionId);
// 当新意图置信度远高于当前 agent 时,允许切换
return confidence > 0.9;
}
// 设置锁定
lockAgent(sessionId: string, agentId: string, ttlMs: number): void {
this.sessions.set(sessionId, {
activeAgent: agentId,
lockUntil: Date.now() + ttlMs,
collectedData: {},
requiredFields: [],
currentField: '',
});
}
// 释放锁定
releaseAgent(sessionId: string): void {
this.sessions.delete(sessionId);
}
}
工作流程示意
用户输入 → 检查会话锁定状态
│
├─→ 有锁定 & 未过期 & 字段未收集完
│ └─→ 强制注册当前 agent(跳过意图识别)
│
├─→ 有锁定 & 新意图置信度 > 阈值(如 0.9)
│ └─→ 允许解锁,执行意图识别
│
└─→ 无锁定 / 已过期 / 字段已收集完
└─→ 正常执行意图识别
对话示例
用户:我想预订一个会议室
系统:[意图识别 → meeting_room_booking] → lockAgent('booking_agent')
booking_agent:好的,请问您需要什么时间?
用户:下午三点
系统:[检测到锁定 → 跳过意图识别,直接路由 booking_agent]
booking_agent:请问参会人数是多少?
用户:帮我查一下明天天气
系统:[检测到锁定 → 仍然路由 booking_agent]
booking_agent:我们正在办理会议室预订,请先告诉我参会人数。
如需查询天气,请回复"取消"结束当前办理。
用户:取消
系统:[释放锁定] → [意图识别 → weather_query]
weather_tool:明天天气晴朗...
优缺点
| 优点 | 缺点 |
|---|---|
| 实现简单,改动最小 | 可能误伤用户的真实意图切换 |
| 保证多轮流程完整性 | 需要合理设置锁定超时时间 |
| 状态管理清晰,易于调试 | 锁定期间无法响应其他意图 |
| 不依赖额外存储 | 用户体验偏"强硬" |
适用场景
- 业务流程明确、字段固定的场景(如表单填写)
- 用户不太可能中途切换意图的场景
- 对完成率要求较高的业务场景
- 快速验证多轮 agent 可行性的初期阶段
与其他方案的关系
会话锁定是最基础的方案,可以作为其他方案的前置条件或降级策略:
- 与**方案六(子意图处理)**组合:锁定期间由 agent 内部处理意外输入,体验更柔和
- 作为**方案五(混合模式)**中关键流程的默认策略
- 作为**方案七(任务栈机制)**的底层锁定原语
方案二:意图优先级 + 软切换(Priority + Soft Switch)
核心思想
不采用硬锁定,而是为不同意图设置优先级权重。当检测到多轮 agent 活跃时,为其添加优先级加成,但不阻止高置信度的新意图切换。本质上是让意图识别从"非黑即白"变成"概率竞争"。
为什么需要这个方案
方案一的硬锁定虽然简单直接,但用户体验偏"强硬"——即使用户非常明确地想切换话题,系统也会强行拉回原流程。这在某些场景下是不可接受的。
软切换的核心改进在于:不再阻止用户切换意图,而是通过优先级加成让当前活跃 agent 获得"主场优势"。如果用户只是随口一问(低置信度),系统会继续当前流程;如果用户明确要切换(高置信度),系统会优雅地放行。
实现方式
interface IntentResult {
intent: string;
confidence: number;
priority: number;
}
class PriorityResolver {
private activeAgents: Map<string, {
agentId: string;
bonus: number;
decayRate: number; // 优先级衰减速率
activatedAt: number;
}> = new Map();
resolve(intents: IntentResult[], sessionId: string): IntentResult[] {
const activeAgent = this.activeAgents.get(sessionId);
if (activeAgent) {
// 计算当前优先级加成(随时间衰减)
const elapsed = Date.now() - activeAgent.activatedAt;
const currentBonus = activeAgent.bonus * Math.exp(-elapsed * activeAgent.decayRate);
// 为活跃 agent 添加优先级加成
const adjusted = intents.map(intent => {
if (intent.intent === activeAgent.agentId) {
return { ...intent, priority: intent.priority + currentBonus };
}
return intent;
});
return adjusted.sort((a, b) => b.priority - a.priority);
}
return intents.sort((a, b) => b.priority - a.priority);
}
// 判断是否应该切换
shouldSwitch(topIntent: IntentResult, sessionId: string): boolean {
const activeAgent = this.activeAgents.get(sessionId);
if (!activeAgent) return true;
const activeIntent = topIntent.intent === activeAgent.agentId
? topIntent
: topIntent.find(i => i.intent === activeAgent.agentId);
// 新意图置信度显著高于当前 agent 时切换
const threshold = 0.3;
return topIntent.confidence - (activeIntent?.confidence || 0) > threshold;
}
// 激活 agent 优先级
activateAgent(sessionId: string, agentId: string, bonus: number = 0.3): void {
this.activeAgents.set(sessionId, {
agentId,
bonus,
decayRate: 0.001, // 每分钟衰减约 5%
activatedAt: Date.now(),
});
}
// 切换时更新
switchAgent(sessionId: string, newAgentId: string): void {
this.activeAgents.delete(sessionId);
this.activateAgent(sessionId, newAgentId);
}
}
工作流程示意
用户输入 → 意图识别(获取所有候选意图及置信度)
│
├─→ 有活跃 agent → 添加优先级加成
│ │
│ ├─→ 活跃 agent 仍为最高优先级 → 继续当前 agent
│ │
│ └─→ 新意图优先级超过阈值 → 切换意图
│ └─→ 更新活跃 agent,重置优先级加成
│
└─→ 无活跃 agent → 直接选择最高优先级意图
对话示例
用户:我想预订一个会议室
系统:[意图识别 → meeting_room_booking (0.92)] → activateAgent(bonus=0.3)
[当前优先级: meeting_room_booking = 0.92 + 0.3 = 1.22]
booking_agent:好的,请问您需要什么时间?
用户:下午三点
系统:[意图识别 → meeting_room_booking (0.85)]
[当前优先级: meeting_room_booking = 0.85 + 0.28(衰减后) = 1.13] → 继续
booking_agent:请问参会人数是多少?
用户:帮我查一下明天天气
系统:[意图识别 → weather_query (0.95), meeting_room_booking (0.1)]
[当前优先级: weather_query = 0.95, meeting_room_booking = 0.1 + 0.25 = 0.35]
[差值 0.6 > 阈值 0.3 → 切换意图]
weather_tool:明天天气晴朗...
用户:5个人
系统:[意图识别 → ??? (低置信度)]
[无匹配意图 → 提示用户重新输入或引导回会议室预订]
参数调优建议
| 参数 | 推荐值 | 说明 |
|---|---|---|
| 优先级加成 (bonus) | 0.2 ~ 0.4 | 过高则难以切换,过低则失去保护意义 |
| 衰减速率 (decayRate) | 0.001 ~ 0.005 | 建议指数衰减,避免线性衰减的突变 |
| 切换阈值 (threshold) | 0.2 ~ 0.4 | 根据业务容忍度调整,电商下单建议偏高 |
优缺点
| 优点 | 缺点 |
|---|---|
| 灵活性高,允许意图切换 | 实现复杂度高于硬锁定 |
| 不会完全阻塞其他意图 | 需要精细调参(加成值、衰减率、阈值) |
| 用户体验更自然、不"强硬" | 可能出现优先级冲突或频繁切换 |
| 支持优先级随时间衰减,更符合实际 | 调参不当可能导致行为不可预测 |
适用场景
- 用户可能中途切换意图的场景
- 需要平衡流程完整性和意图响应性的场景
- 有足够数据来调优优先级参数的场景
- 对用户体验要求高于实现成本的场景
与其他方案的关系
- 与**方案六(子意图处理)**组合:优先级加成解决全局路由问题,子意图处理解决 agent 内部意外输入
- 作为**方案五(混合模式)**的默认策略
- 可作为**方案一(会话锁定)**的平滑升级路径
方案三:状态持久化 + 延迟注册(State Persistence + Deferred Registration)
核心思想
将多轮 agent 的状态持久化到外部存储,即使某轮对话中该 agent 未被注册,下一轮用户输入回到该 agent 范畴时,能够从存储中恢复之前的状态继续执行,无需用户重新填写已提供的信息。
为什么需要这个方案
方案一和方案二都假设"agent 不被注册 = 流程中断"。但如果换个思路:中断就中断,只要状态还在就行。状态持久化的核心哲学是:不怕被打断,就怕记不住。
这种方案特别适合用户行为高度不确定的场景——用户可能今天填了一半的表单,明天才回来继续。没有持久化,一切体验优化都是空谈。
实现方式
interface AgentState {
agentId: string;
sessionId: string;
collectedData: Record<string, any>;
currentStep: number;
totalSteps: number;
lastActiveAt: number;
expiresAt: number;
}
class StateManager {
private stateStore: StateStore;
async saveState(state: AgentState): Promise<void> {
await this.stateStore.set(
`agent_state:${state.sessionId}:${state.agentId}`,
state,
{ ttl: state.expiresAt - Date.now() }
);
}
async restoreState(sessionId: string, agentId: string): Promise<AgentState | null> {
return await this.stateStore.get(`agent_state:${sessionId}:${agentId}`);
}
async cleanupExpiredStates(): Promise<void> {
// 定期清理过期状态
}
}
// 在 agent 注册时检查是否有待恢复的状态
class AgentRegistry {
async registerAgent(agentId: string, sessionId: string): Promise<Agent> {
const state = await this.stateManager.restoreState(sessionId, agentId);
if (state) {
// 恢复之前的状态,继续执行
return this.createAgentWithState(agentId, state);
}
// 正常注册新 agent
return this.createAgent(agentId);
}
}
工作流程示意
用户输入 → 意图识别
│
├─→ 匹配到 agent → 检查是否有持久化状态
│ │
│ ├─→ 有状态 → 恢复状态,继续执行
│ │ └─→ "您之前已经提供了 X 信息,接下来请提供 Y"
│ │
│ └─→ 无状态 → 正常启动新 agent
│
└─→ 未匹配到 agent → 不操作(状态保留在存储中)
└─→ 等待用户下次回到该 agent 范畴
对话示例
用户:我想预订一个会议室
系统:[意图识别 → meeting_room_booking] → 注册 booking_agent
booking_agent:好的,请问您需要什么时间?
用户:下午三点
系统:[saveState: {time: '下午三点'}]
booking_agent:请问参会人数是多少?
用户:对了,帮我查一下明天天气
系统:[意图识别 → weather_query] → [saveState 保留 booking 状态]
weather_tool:明天天气晴朗...
[用户去做别的事了...]
[第二天]
用户:我想继续预订会议室
系统:[意图识别 → meeting_room_booking] → [restoreState: {time: '下午三点'}]
booking_agent:您之前已经登记了下午3点的时间。请问参会人数是多少?
优缺点
| 优点 | 缺点 |
|---|---|
| 最灵活,允许任意意图切换 | 实现复杂度较高 |
| 用户可随时回到之前的流程 | 需要额外的存储和清理机制 |
| 支持跨会话恢复(隔天继续) | 状态冲突处理复杂 |
| 不阻塞其他意图 | 需要考虑状态过期策略 |
| 天然适配方案六(子意图处理) | 存储成本随用户量增长 |
适用场景
- 用户行为高度不确定的场景
- 需要支持跨会话恢复的场景(如隔天继续填写)
- 对用户体验要求极高的场景
- 有足够工程资源实现状态管理的团队
与其他方案的关系
- 与**方案六(子意图处理)**天然兼容:槽位状态可直接持久化
- 与方案一/二互补:持久化保证状态不丢失,锁定/优先级保证流程不被打断
- 是**方案五(混合模式)**中"关键流程"的基础设施
方案四:全局上下文感知(Global Context Awareness)
核心思想
在意图识别阶段,将当前活跃的 agent 上下文作为额外输入注入到意图识别模型中,让模型能够理解"用户当前正在与某个 agent 交互"这一事实,从而做出更智能的判断。
为什么需要这个方案
前三种方案都在"路由层"做文章——要么锁定、要么优先级、要么恢复状态。但它们都有一个共同前提:意图识别本身是无上下文的。
方案四的思路更根本:让意图识别本身变得有上下文。既然 LLM 已经具备了强大的上下文理解能力,为什么不直接把"当前正在进行的任务"告诉它,让它来做判断呢?
实现方式
interface ContextAwareIntent {
userInput: string;
activeAgents: Array<{
agentId: string;
currentStep: string;
collectedData: Record<string, any>;
}>;
conversationHistory: Message[];
}
class ContextAwareIntentRecognition {
async recognize(context: ContextAwareIntent): Promise<IntentResult[]> {
// 将活跃 agent 上下文注入 prompt
const prompt = this.buildPrompt(context);
const result = await this.llm.generate(prompt);
// LLM 会考虑当前上下文,做出更合理的判断
return this.parseResult(result);
}
private buildPrompt(context: ContextAwareIntent): string {
return `
用户输入:${context.userInput}
当前活跃的 Agent:
${context.activeAgents.map(a =>
`- ${a.agentId} (当前步骤: ${a.currentStep}, 已收集: ${JSON.stringify(a.collectedData)})`
).join('\n')}
请判断用户意图:
1. 如果用户正在回复当前活跃 agent 的问题,返回对应 agent
2. 如果用户明确切换话题,返回新意图
3. 如果用户输入模糊,优先返回活跃 agent
`;
}
}
工作流程示意
用户输入 + 当前活跃 agent 上下文
│
└─→ 构建上下文感知的 Prompt
│
└─→ LLM 意图识别(同时考虑用户输入和当前上下文)
│
├─→ 判断为回复当前 agent → 返回当前 agent
├─→ 判断为切换话题 → 返回新意图
└─→ 判断为模糊输入 → 优先返回当前 agent
对话示例
用户:我想预订一个会议室
系统:[意图识别 → meeting_room_booking]
booking_agent:好的,请问您需要什么时间?
用户:下午三点
系统:[意图识别(上下文:当前正在预订会议室,等待时间)→ meeting_room_booking]
booking_agent:请问参会人数是多少?
用户:帮我查一下明天天气
系统:[意图识别(上下文:当前正在预订会议室,等待人数)]
[LLM 判断:用户明确切换话题 → weather_query]
weather_tool:明天天气晴朗...
用户:5个人
系统:[意图识别(上下文:无活跃 agent)]
[LLM 判断:模糊输入,但"5个人"可能是对之前问题的回答]
[由于无活跃 agent,提示:您之前正在预订会议室,请问是要继续吗?]
优缺点
| 优点 | 缺点 |
|---|---|
| 最智能,LLM 自主判断 | 依赖 LLM 能力,可能不稳定 |
| 不需要硬编码规则 | 每次识别消耗更多 token |
| 可处理复杂场景 | 延迟较高 |
| 易于扩展 | 需要精心设计的 prompt |
| 最贴近人类对话理解方式 | LLM 输出可能不一致,需要兜底策略 |
适用场景
- 有强大 LLM 支持的场景
- 用户输入多样化的场景
- 愿意为智能性牺牲一定性能和成本的场景
- 对话流程复杂、难以用规则覆盖的场景
Prompt 设计建议
| 原则 | 说明 |
|---|---|
| 简洁 | 只注入必要上下文,避免 prompt 过长 |
| 结构化 | 使用清晰的格式描述当前状态 |
| 明确判断标准 | 告诉 LLM 什么情况下应该切换、什么情况下应该保持 |
| 兜底策略 | LLM 判断不确定时,提供 fallback 机制 |
与其他方案的关系
- 可作为**方案五(混合模式)**中"智能判断"的实现方式
- 与**方案六(子意图处理)**互补:全局上下文感知解决路由层判断,子意图处理解决 agent 内部理解
- 可作为**方案二(优先级+软切换)**的智能升级版
方案五:Agent 内部"子意图"处理 + 超时降级(Internal Sub-Intent + Timeout Fallback)
核心思想
让多轮 agent 自己具备处理"意外输入"的能力,而不是完全依赖全局路由。核心思路是:将意图处理的边界从全局路由下沉到 agent 内部,让 agent 自行判断用户输入是"正在回答我的问题"、"偏离但可引导"还是"明确要结束"。
为什么需要这个方案
前四种方案都将"意图识别"和"agent 注册"视为全局路由层的职责。但这种方式有一个根本性缺陷:全局路由无法理解 agent 内部的对话上下文。
例如,一个"预订会议室"的 agent 正在等待用户输入"参会人数",用户回答"大概10个人左右吧"——这句话从全局意图识别来看,可能无法匹配任何已知意图(因为没有明确的动词或关键词),但如果由 agent 自身来处理,它能理解这是对"参会人数"问题的回答。
实现方式
interface Slot {
name: string;
description: string;
type: 'text' | 'number' | 'date' | 'enum';
required: boolean;
extracted?: any;
prompt?: string; // 引导用户输入的提示语
}
interface SubIntentResult {
type: 'slot_fill' | 'out_of_scope' | 'cancel' | 'complete';
slotName?: string;
extractedValue?: any;
confidence: number;
}
class AgentWithSubIntent {
private slots: Slot[];
private timeoutTimer: NodeJS.Timeout | null = null;
private retryCount: number = 0;
private maxRetries: number = 3;
private timeoutMs: number = 5 * 60 * 1000; // 5分钟超时
constructor(slots: Slot[]) {
this.slots = slots;
this.resetTimeout();
}
// 处理用户输入 - 优先尝试内部子意图识别
async handleInput(userInput: string): Promise<SubIntentResult> {
this.resetTimeout();
// Step 1: 尝试用轻量模型/规则提取槽位信息
const slotResult = await this.extractSlotValue(userInput);
if (slotResult) {
this.retryCount = 0; // 重置重试计数
return slotResult;
}
// Step 2: 检查是否是取消指令
if (this.isCancelIntent(userInput)) {
return { type: 'cancel', confidence: 1.0 };
}
// Step 3: 检查是否已完成所有必填槽位
if (this.allRequiredSlotsFilled()) {
return { type: 'complete', confidence: 1.0 };
}
// Step 4: 超出范围,引导用户
this.retryCount++;
if (this.retryCount >= this.maxRetries) {
// 超时降级:释放焦点,回到全局意图识别
return { type: 'out_of_scope', confidence: 0 };
}
// 主动引导
const currentSlot = this.getNextEmptySlot();
const guideMessage = this.buildGuideMessage(currentSlot);
return {
type: 'out_of_scope',
confidence: 0,
// 附带引导信息,由外层返回给用户
guideMessage: guideMessage,
};
}
// 使用轻量模型提取槽位值
private async extractSlotValue(input: string): Promise<SubIntentResult | null> {
const currentSlot = this.getNextEmptySlot();
if (!currentSlot) return null;
// 可以使用小模型(如 GPT-3.5-turbo、本地模型)或规则引擎
const prompt = `
当前正在收集:${currentSlot.name}(${currentSlot.description})
用户输入:${input}
请判断用户输入是否是在回答这个问题。如果是,提取对应的值。
返回 JSON: {"matched": true/false, "value": ...}
`;
const result = await this.lightweightLLM.generate(prompt);
if (result.matched) {
currentSlot.extracted = result.value;
return {
type: 'slot_fill',
slotName: currentSlot.name,
extractedValue: result.value,
confidence: result.confidence || 0.8,
};
}
return null;
}
// 构建引导消息
private buildGuideMessage(slot: Slot): string {
const filledSlots = this.slots.filter(s => s.extracted !== undefined);
const progress = `[${filledSlots.length}/${this.slots.filter(s => s.required).length}]`;
return `${progress} 我们正在办理${this.taskName},当前还需要您提供【${slot.name}】信息。
您可以输入相关信息,或输入"取消"结束当前办理。`;
}
// 超时处理
private resetTimeout(): void {
if (this.timeoutTimer) clearTimeout(this.timeoutTimer);
this.timeoutTimer = setTimeout(() => {
this.emit('timeout'); // 触发超时事件,外层可据此释放焦点
}, this.timeoutMs);
}
// 释放焦点
release(): void {
if (this.timeoutTimer) clearTimeout(this.timeoutTimer);
this.emit('released');
}
}
工作流程示意
用户输入
│
├─→ Agent 内部子意图识别
│ ├─ 槽位匹配成功 → 填充槽位,继续下一轮
│ ├─ 取消意图 → 结束当前 agent,释放焦点
│ ├─ 已完成所有槽位 → 执行最终服务调用
│ └─ 超出范围
│ ├─ 重试次数 < 上限 → 主动引导用户
│ └─ 重试次数 >= 上限 → 释放焦点,回到全局路由
│
└─→ 全局意图识别(仅当 agent 未注册或已释放焦点时)
对话示例
用户:我想预订一个会议室
系统:[意图识别 → meeting_room_booking] → 注册 booking_agent
booking_agent:好的,请问您需要什么时间?
用户:下午三点
[子意图识别:slot_fill → time = "下午三点"] ✓
booking_agent:请问参会人数是多少?
用户:今天天气真不错
[子意图识别:out_of_scope (第1次)]
booking_agent:[1/4] 我们正在办理会议室预订,当前还需要您提供【参会人数】信息。
您可以输入相关信息,或输入"取消"结束当前办理。
用户:哈哈
[子意图识别:out_of_scope (第2次)]
booking_agent:[1/4] 我们正在办理会议室预订,当前还需要您提供【参会人数】信息。
您可以输入相关信息,或输入"取消"结束当前办理。
用户:好吧,5个人
[子意图识别:slot_fill → count = 5] ✓
booking_agent:收到,5人。请问需要投影设备吗?
优缺点
| 优点 | 缺点 |
|---|---|
| 不依赖全局路由,agent 自治性强 | 每个 agent 需要单独实现子意图处理逻辑 |
| 使用轻量模型,成本低 | 需要为每个 agent 定义槽位和提取规则 |
| 用户引导体验好,有明确进度提示 | 超时策略需要合理设置 |
| 支持降级机制,不会无限循环 | 对模糊输入的容忍度取决于模型能力 |
| 可与其他方案组合使用 | 增加了 agent 内部的复杂度 |
适用场景
- 槽位明确、流程固定的多轮对话(如预订、申请、查询)
- 希望降低全局路由复杂度的场景
- 对成本敏感,希望用轻量模型处理大部分输入
- 需要给用户明确进度反馈的业务场景
与其他方案的关系
方案五不是一个独立的"全局策略",而是一个 agent 级别的增强机制,可以与方案一至方案四组合使用:
- 与会话锁定组合:锁定期间由 agent 内部处理子意图
- 与优先级+软切换组合:agent 内部处理 + 全局优先级加成
- 与状态持久化组合:槽位状态天然可持久化
- 与上下文感知组合:子意图识别结果可作为全局上下文的一部分
方案六:任务栈机制(Task Stack — 支持挂起、唤醒与嵌套)

核心思想
引入类似浏览器页面栈或函数调用栈的任务栈(Task Stack)机制,支持 agent 在执行过程中被挂起(push)、执行其他 agent 后恢复(pop),实现多 agent 之间的嵌套调用和无缝切换。
为什么需要这个方案
方案一至方案五都假设"同一时间只有一个活跃 agent"。但现实中,用户的行为往往更加复杂:
用户:帮我预订明天下午3点的会议室
Agent A:好的,请问参会人数是多少?
用户:对了,先帮我查一下张三的日程安排
[Agent A 被挂起,Agent B 执行]
Agent B:张三明天下午3点有空
用户:好的,那就5个人吧
[Agent B 完成,Agent A 恢复]
Agent A:收到,已为您预订5人的会议室。还需要其他设备吗?
这种场景下,用户并不是"切换意图",而是临时插入一个新任务,完成后希望回到之前的任务继续。这正是任务栈机制要解决的问题。
核心数据结构
interface TaskFrame {
taskId: string;
agentId: string;
state: Record<string, any>; // agent 执行状态
suspendedAt: number; // 挂起时间戳
resumePrompt?: string; // 恢复时的提示语
priority: number; // 优先级(影响栈内排序)
}
class TaskStack {
private stack: TaskFrame[] = [];
private maxDepth: number = 5; // 最大嵌套深度
private maxSuspendTime: number = 30 * 60 * 1000; // 最大挂起时间 30 分钟
// 挂起当前 agent,推入新 agent
push(newFrame: TaskFrame): TaskFrame | null {
if (this.stack.length >= this.maxDepth) {
return null; // 栈满,拒绝嵌套
}
const currentTop = this.stack[this.stack.length - 1];
if (currentTop) {
currentTop.suspendedAt = Date.now();
currentTop.resumePrompt = this.generateResumePrompt(currentTop);
}
this.stack.push(newFrame);
return currentTop; // 返回被挂起的 frame
}
// 完成当前 agent,弹出栈,恢复上一个
pop(): TaskFrame | null {
if (this.stack.length <= 1) {
return null; // 栈底,无任务可恢复
}
const completed = this.stack.pop();
const resumed = this.stack[this.stack.length - 1];
// 检查挂起是否超时
if (resumed && (Date.now() - resumed.suspendedAt > this.maxSuspendTime)) {
this.stack.pop(); // 超时,丢弃该任务
return this.pop(); // 继续弹出,直到找到未超时的
}
return resumed;
}
// 获取当前活跃的 agent
get activeAgent(): TaskFrame | null {
return this.stack[this.stack.length - 1] || null;
}
// 生成恢复提示
private generateResumePrompt(frame: TaskFrame): string {
const prompts: Record<string, string> = {
'meeting_room_booking': '我们继续会议室预订',
'leave_request': '我们继续请假申请',
'expense_report': '我们继续报销流程',
};
return prompts[frame.agentId] || '我们继续之前的办理';
}
// 清理超时任务
cleanup(): void {
const now = Date.now();
this.stack = this.stack.filter(frame =>
!frame.suspendedAt || (now - frame.suspendedAt <= this.maxSuspendTime)
);
}
}
完整工作流程
用户输入 → 意图识别
│
├─→ 新意图与当前活跃 agent 无关
│ │
│ ├─ 任务栈未满 → push 新 agent,挂起当前 agent
│ │ │
│ │ ├─ 新 agent 执行完成 → pop,恢复上一个 agent
│ │ │ └─ 输出恢复提示:"我们继续刚才的 XXX"
│ │ │
│ │ └─ 用户再次插入新任务 → 继续 push(不超过 maxDepth)
│ │
│ └─ 任务栈已满 → 拒绝嵌套,引导用户完成当前任务
│
└─→ 新意图与当前活跃 agent 相关
└─→ 继续当前 agent 执行
对话示例
用户:我想预订明天下午3点的会议室
─────────────────────────────────
[TaskStack] push meeting_room_booking
Agent A:好的,请问参会人数是多少?
用户:对了,先帮我查一下张三明天下午的日程
─────────────────────────────────
[TaskStack] push schedule_query (挂起 meeting_room_booking)
Agent B:张三明天下午3点有空,没有冲突。
用户:好的,那就5个人吧
─────────────────────────────────
[TaskStack] pop schedule_query → resume meeting_room_booking
Agent A:我们继续会议室预订。已为您登记5人,请问需要投影设备吗?
用户:需要,另外帮我订一杯咖啡送到会议室
─────────────────────────────────
[TaskStack] push catering_service (挂起 meeting_room_booking)
Agent C:好的,已为您预订一杯美式咖啡,明天下午2:50送到会议室。
用户:好的
─────────────────────────────────
[TaskStack] pop catering_service → resume meeting_room_booking
Agent A:我们继续会议室预订。已为您添加投影设备和咖啡服务。
请问还有其他需求吗?
用户:没有了
─────────────────────────────────
[TaskStack] pop meeting_room_booking (任务完成)
系统:会议室预订已完成。如有需要,随时为您服务。
边界情况处理
class TaskStackManager {
// 1. 栈满处理
handleStackFull(input: string): Response {
const top = this.stack[this.stack.length - 1];
return {
message: `当前正在办理【${top.agentName}】,请先完成当前操作。
您已嵌套了 ${this.stack.length} 个任务,最多支持 ${this.maxDepth} 个。`,
action: 'block',
};
}
// 2. 超时恢复处理
handleExpiredResume(): Response {
return {
message: '抱歉,之前的办理已超时失效。如需继续,请重新发起。',
action: 'discard',
};
}
// 3. 用户主动取消当前任务
handleUserCancel(): TaskFrame | null {
const cancelled = this.stack.pop();
const resumed = this.activeAgent;
if (resumed) {
return {
message: `已取消【${cancelled.agentName}】。${resumed.resumePrompt}`,
action: 'resume',
};
}
return {
message: '已取消当前办理。',
action: 'idle',
};
}
// 4. 意图识别时考虑栈顶上下文
recognizeWithContext(input: string): IntentResult {
const activeAgent = this.activeAgent;
if (activeAgent) {
// 将当前活跃 agent 信息注入意图识别
return this.intentRecognition(input, {
activeAgentId: activeAgent.agentId,
activeAgentState: activeAgent.state,
});
}
return this.intentRecognition(input);
}
}
优缺点
| 优点 | 缺点 |
|---|---|
| 最贴近真实用户行为模式 | 实现复杂度最高 |
| 支持任意深度的任务嵌套 | 需要精心设计栈的管理逻辑 |
| 用户体验极佳,无缝切换 | 状态管理复杂,容易出 bug |
| 自然支持"临时插入任务"场景 | 调试和排查问题困难 |
| 与方案五(子意图处理)天然兼容 | 最大深度和超时策略需要调优 |
适用场景
- 用户行为高度自由、频繁插入临时任务的场景
- 需要支持多 agent 协作的复杂业务平台
- 对用户体验有极致要求的场景
- 有充足工程资源投入的团队
与方案五的组合
任务栈机制与方案五(子意图处理)是天然互补的关系:
全局路由层:TaskStack 管理 agent 级别的挂起/恢复
│
└─→ Agent 内部:Sub-Intent 处理槽位填充和意外输入
│
└─→ 轻量模型提取槽位值
└─→ 引导用户继续填写
└─→ 超时降级释放焦点
这种组合方式可以同时获得:
- 全局层面:多 agent 嵌套、挂起、恢复的能力
- 局部层面:每个 agent 内部的槽位管理、引导、降级能力
方案七:混合模式(Hybrid Approach)
核心思想
结合上述六种方案的优点,在不同场景下采用不同策略,实现按场景配置、按需组合的灵活架构:
- 默认:使用意图优先级 + 软切换
- 关键流程:使用会话锁定(如支付、预订)
- 状态恢复:对重要 agent 启用状态持久化
- 智能判断:在边界情况下使用 LLM 辅助决策
- Agent 自治:为每个 agent 启用子意图处理
- 任务嵌套:为复杂场景启用任务栈机制
为什么需要这个方案
前六种方案各有优劣,但真实业务场景往往是多种场景共存的。一个企业内部可能同时存在:
- 简单的查询类 agent(天气、日程)—— 不需要复杂的状态管理
- 表单填写类 agent(预订、申请)—— 需要槽位管理和引导
- 复杂流程类 agent(报销、审批)—— 可能需要任务嵌套
混合模式的核心价值在于:不要求所有 agent 使用同一套策略,而是让每个 agent 根据自身特点选择最合适的方案组合。
实现方式
interface AgentConfig {
agentId: string;
// 核心策略(必选其一)
strategy: 'lock' | 'priority' | 'persistent' | 'context-aware' | 'task-stack';
// 增强机制(可选,可组合)
enhancements: {
subIntent?: boolean; // 是否启用子意图处理
statePersistence?: boolean; // 是否启用状态持久化
contextAware?: boolean; // 是否启用上下文感知
};
// 策略参数
lockTimeout?: number;
priorityBonus?: number;
maxStackDepth?: number;
}
class HybridAgentManager {
private configs: Map<string, AgentConfig> = new Map();
private taskStack: TaskStack = new TaskStack();
private sessionManager: SessionManager = new SessionManager();
private priorityResolver: PriorityResolver = new PriorityResolver();
private stateManager: StateManager = new StateManager();
async resolve(input: string, sessionId: string): Promise<ResolutionResult> {
const session = this.getSession(sessionId);
const activeAgent = session?.activeAgent;
if (!activeAgent) {
return this.normalResolve(input);
}
const config = this.configs.get(activeAgent);
// Step 1: 应用核心策略
const coreResult = await this.applyCoreStrategy(input, sessionId, config);
// Step 2: 应用增强机制
const enhancedResult = await this.applyEnhancements(
coreResult, input, sessionId, config
);
return enhancedResult;
}
private async applyCoreStrategy(
input: string,
sessionId: string,
config: AgentConfig
): Promise<ResolutionResult> {
switch (config.strategy) {
case 'lock':
return this.handleLockMode(input, sessionId, config);
case 'priority':
return this.handlePriorityMode(input, sessionId, config);
case 'persistent':
return this.handlePersistentMode(input, sessionId, config);
case 'context-aware':
return this.handleContextAwareMode(input, sessionId, config);
case 'task-stack':
return this.handleTaskStackMode(input, sessionId, config);
default:
return this.normalResolve(input);
}
}
private async applyEnhancements(
result: ResolutionResult,
input: string,
sessionId: string,
config: AgentConfig
): Promise<ResolutionResult> {
// 子意图处理:在路由决策后,让 agent 内部处理意外输入
if (config.enhancements.subIntent && result.agentId) {
const agent = await this.getAgent(result.agentId);
const subIntentResult = await agent.handleInput(input);
if (subIntentResult.type === 'out_of_scope' && subIntentResult.guideMessage) {
return { ...result, guideMessage: subIntentResult.guideMessage };
}
}
// 状态持久化:保存当前状态
if (config.enhancements.statePersistence) {
await this.stateManager.saveState(result.state);
}
return result;
}
}
配置示例
// 不同 agent 使用不同策略
const agentConfigs: AgentConfig[] = [
{
agentId: 'meeting_room_booking',
strategy: 'priority',
enhancements: {
subIntent: true, // 启用子意图处理
statePersistence: true, // 启用状态持久化
},
priorityBonus: 0.3,
},
{
agentId: 'payment_process',
strategy: 'lock', // 支付流程强制锁定
enhancements: {
subIntent: true,
statePersistence: true,
},
lockTimeout: 10 * 60 * 1000, // 10分钟锁定
},
{
agentId: 'weather_query',
strategy: 'priority', // 简单查询,不需要复杂管理
enhancements: {},
priorityBonus: 0.1,
},
{
agentId: 'expense_report',
strategy: 'task-stack', // 报销流程支持嵌套
enhancements: {
subIntent: true,
statePersistence: true,
contextAware: true,
},
maxStackDepth: 3,
},
];
优缺点
| 优点 | 缺点 |
|---|---|
| 最灵活,可按需选择策略 | 实现和维护成本最高 |
| 适应不同业务场景 | 需要为每个 agent 配置策略 |
| 平衡性能、成本和体验 | 调试和监控复杂度高 |
| 可渐进式引入 | 需要完善的监控和可观测性 |
| 支持策略热更新 | 配置管理需要额外工具 |
适用场景
- 多业务线、多场景的复杂系统
- 有不同 SLA 要求的 agent 共存
- 团队有足够的工程能力
- 需要长期演进的平台级产品
配置管理建议
| 维度 | 建议 |
|---|---|
| 配置存储 | 使用数据库或配置中心,支持热更新 |
| 配置校验 | 启动时校验配置合法性 |
| 监控指标 | 记录每个 agent 的策略命中率、切换频率 |
| 灰度发布 | 新策略先在小范围 agent 上验证 |
| 降级策略 | 当混合管理器异常时,降级为简单的意图识别 |
5. 解决方案对比

5.1 综合对比表
| 维度 | 会话锁定 | 优先级+软切换 | 状态持久化 | 上下文感知 | 子意图+超时降级 | 任务栈机制 | 混合模式 |
|---|---|---|---|---|---|---|---|
| 实现复杂度 | ⭐ | ⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| 灵活性 | ⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| 用户体验 | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| 性能开销 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ |
| 维护成本 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐ |
| 适用场景广度 | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
5.2 选择建议
| 你的场景 | 推荐方案 | 理由 |
|---|---|---|
| 简单表单填写,流程固定 | 会话锁定 | 实现成本最低,效果最好 |
| 用户可能中途切换话题 | 优先级+软切换 | 平衡灵活性和完整性 |
| 高价值业务流程(如电商下单) | 状态持久化 | 确保不丢失任何用户输入 |
| 有强大 LLM 支持,追求智能 | 上下文感知 | LLM 自主判断最符合人类直觉 |
| 槽位明确,希望 agent 自治 | 子意图+超时降级 | 降低全局路由负担,agent 自行处理意外输入 |
| 用户频繁插入临时任务 | 任务栈机制 | 支持嵌套、挂起、恢复,最贴近真实行为 |
| 多业务线、多场景共存 | 混合模式 | 不同场景不同策略,最优解 |
5.3 渐进式落地路径
如果你正在从零开始构建这个能力,建议按以下路径渐进式落地:
Phase 1: 会话锁定(1-2周)
→ 快速验证多轮 agent 可行性
Phase 2: 优先级+软切换(2-3周)
→ 提升用户体验,允许意图切换
Phase 3: 子意图+超时降级(2-3周)
→ 让 agent 具备自治能力,降低全局路由负担
Phase 4: 状态持久化(3-4周)
→ 支持跨轮次状态恢复
Phase 5: 上下文感知(按需引入)
→ 在边界场景引入 LLM 辅助决策
Phase 6: 任务栈机制(按需引入)
→ 当出现频繁的任务嵌套需求时引入
Phase 7: 混合模式(长期演进)
→ 按业务需求配置不同策略
6. 总结
多轮 agent 在动态意图识别环境下的生命周期管理,本质上是一个状态管理与意图切换之间的平衡问题。没有银弹,只有最适合你当前场景的方案。
七种方案的本质差异
| 方案 | 核心思路 | 控制层级 |
|---|---|---|
| 会话锁定 | 硬锁定,独占焦点 | 全局路由层 |
| 优先级+软切换 | 软优先级,允许高置信度切换 | 全局路由层 |
| 状态持久化 | 状态可恢复,不怕中断 | 存储层 |
| 上下文感知 | LLM 理解全局上下文后自主判断 | 意图识别层 |
| 子意图+超时降级 | agent 内部处理意外输入,超时自动释放 | Agent 内部 |
| 任务栈机制 | 挂起/恢复/嵌套,支持多任务并行 | 全局调度层 |
| 混合模式 | 按场景选择策略,组合使用 | 全局编排层 |
核心要点
- 明确你的业务场景:用户是否会中途切换意图?流程是否固定?是否需要任务嵌套?
- 从简单开始:先实现会话锁定,再逐步引入更复杂的策略
- 状态是关键:无论采用哪种方案,都要确保状态不丢失
- 分层思考:全局路由层解决"选哪个 agent"的问题,agent 内部解决"怎么处理意外输入"的问题
- 组合优于单一:方案五(子意图处理)和方案六(任务栈)天然互补,组合使用效果最佳
- 监控和可观测性:记录每次意图识别的结果和 agent 注册情况,便于调优
- 用户测试:最终评判标准是用户体验,而非技术优雅度
希望这篇文章能帮助你更好地设计和实现多轮 agent 的生命周期管理。
参考资料
| 参考资料 | 访问地址 |
|---|---|
| LangGraph - Stateful Multi-Agent Workflows | https://langchain-ai.github.io/langgraph/ |
| Microsoft AutoGen - Multi-Agent Conversation Framework | https://microsoft.github.io/autogen/ |
| CrewAI - Role-Based Multi-Agent Framework | https://docs.crewai.com/ |
| OpenAI Function Calling | https://platform.openai.com/docs/guides/function-calling |
| Google Gemini - Tool Use | https://ai.google.dev/gemini-api/docs/function-calling |
作者:一灰
日期:2026-04-03
标签: #AI #Agent #多轮对话 #意图识别 #状态管理 #架构设计 #任务栈 #子意图