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

一灰灰blogAgentAgent动态意图识别约 9623 字大约 32 分钟

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

HA06-01.png
HA06-01.png

1. 引言

在构建基于 AI 的对话系统时,我们常常需要将现有的服务能力封装为 AI 对话的 tool,或者将多个服务能力打包为一个 agent 供 AI 对话交互使用。当已有服务能力较多时,基于用户交互的意图识别 + 动态注册服务能力成为一种常见的架构选择。

然而,这种架构在面对多轮引导式信息收集场景时,会出现一个核心问题:用户输入的内容可能因意图识别与当前 agent 无关联,导致该 agent 未被注册,从而造成整个多轮对话流程的意外中断。

本文将深入探讨这一问题的本质,分析多种可行的解决方案,并对各方案进行对比,帮助你在实际项目中做出合适的架构决策。

2. 问题背景

2.1 典型架构模式

在现代 AI 对话系统中,常见的架构模式如下:

用户输入 → 意图识别模块 → 动态注册匹配的 Tool/Agent → LLM 调用 → 返回结果

这种模式的优势在于:

  • 按需加载:只注册与当前意图相关的服务,减少 token 消耗
  • 扩展性强:新增服务能力只需注册即可,无需修改核心逻辑
  • 资源高效:避免将所有 tool 一次性注入 prompt
HA06-02.png
HA06-02.png

2.2 多轮 Agent 的特殊性

多轮引导式 agent 的典型特征是:

  • 需要跨多轮对话维持状态
  • 每轮对话中,agent 会向用户提出问题,收集特定信息
  • 用户回答可能偏离当前 agent 的意图范畴
  • 信息收集完成后,agent 才会执行最终的服务调用

例如,一个"预订会议室"的 agent 可能需要多轮对话来收集:

  1. 会议时间
  2. 参会人数
  3. 设备需求
  4. 特殊要求

在这个过程中,用户可能会突然问:"今天天气怎么样?"——这显然与会议室预订无关。

3. 问题说明

3.1 核心矛盾

问题的核心矛盾在于:

维度动态意图识别多轮 Agent
设计目标每轮独立识别最相关意图维持跨轮次的对话状态
注册策略仅注册匹配当前意图的服务需要持续注册直至任务完成
状态管理无状态或弱状态强状态依赖

当用户输入偏离当前 agent 的意图范畴时,意图识别模块可能:

  1. 完全忽略当前活跃的 agent
  2. 注册其他更匹配的 tool/agent
  3. 导致当前 agent 失去执行机会
HA06-03.png
HA06-03.png

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. 解决方案

HA06-04.png
HA06-04.png

方案一: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 — 支持挂起、唤醒与嵌套)

HA06-05.png
HA06-05.png

核心思想

引入类似浏览器页面栈或函数调用栈的任务栈(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. 解决方案对比

HA06-06.png
HA06-06.png

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 内部
任务栈机制挂起/恢复/嵌套,支持多任务并行全局调度层
混合模式按场景选择策略,组合使用全局编排层

核心要点

  1. 明确你的业务场景:用户是否会中途切换意图?流程是否固定?是否需要任务嵌套?
  2. 从简单开始:先实现会话锁定,再逐步引入更复杂的策略
  3. 状态是关键:无论采用哪种方案,都要确保状态不丢失
  4. 分层思考:全局路由层解决"选哪个 agent"的问题,agent 内部解决"怎么处理意外输入"的问题
  5. 组合优于单一:方案五(子意图处理)和方案六(任务栈)天然互补,组合使用效果最佳
  6. 监控和可观测性:记录每次意图识别的结果和 agent 注册情况,便于调优
  7. 用户测试:最终评判标准是用户体验,而非技术优雅度

希望这篇文章能帮助你更好地设计和实现多轮 agent 的生命周期管理。

参考资料

参考资料访问地址
LangGraph - Stateful Multi-Agent Workflowshttps://langchain-ai.github.io/langgraph/open in new window
Microsoft AutoGen - Multi-Agent Conversation Frameworkhttps://microsoft.github.io/autogen/open in new window
CrewAI - Role-Based Multi-Agent Frameworkhttps://docs.crewai.com/open in new window
OpenAI Function Callinghttps://platform.openai.com/docs/guides/function-callingopen in new window
Google Gemini - Tool Usehttps://ai.google.dev/gemini-api/docs/function-callingopen in new window

作者:一灰
日期:2026-04-03
标签: #AI #Agent #多轮对话 #意图识别 #状态管理 #架构设计 #任务栈 #子意图

Loading...