Agentic Reasoning（智能体推理）

概述

Agentic Reasoning（智能体推理） 是大语言模型（LLM）领域的重要研究方向，代表了从”被动推理”到”主动行动”的根本性范式转变。与传统LLM推理依赖静态输入和内部推理不同，Agentic Reasoning将LLM重塑为自主智能体，能够进行规划（Plan）、行动（Act）、并通过持续反馈实现学习和适应。¹

传统LLM推理通常被建模为单次或少样本预测任务，依赖增加模型规模或推理预算来提升准确率，但缺乏与环境交互、记忆和适应动态目标的能力。Agentic Reasoning则通过引入外部工具、结构化记忆和多智能体协作，突破了这一局限。¹

核心观点：Agentic Reasoning = 推理（Reasoning）+ 行动（Acting）+ 反思（Reflection）+ 协作（Coordination）

---

定义：推理作为智能体的核心机制

形式化定义

Agentic Reasoning可被定义为一种使LLM能够在开放、动态环境中实现复杂目标的推理框架。其核心在于将推理过程从静态的”思考输出”转变为持续的环境交互循环：

$$\text{AgenticReasoning}=⟨P,A,O,M,C⟩$$

其中：

• $P$：规划模块（Planning）—— 目标分解与策略生成
• $A$：行动模块（Acting）—— 工具调用与环境交互
• $O$：观察模块（Observation）—— 感知反馈与状态更新
• $M$：记忆模块（Memory）—— 跨步态经验存储与检索
• $C$：协作模块（Coordination）—— 多智能体通信与协调

推理循环

┌─────────────────────────────────────────────────────────────┐
│                  Agentic Reasoning 循环                      │
│                                                             │
│    ┌─────────┐                                             │
│    │  目标    │ ← ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─  │
│    └────┬────┘      任务完成 / 重新规划                      │
│         │                                                    │
│         ↓                                                    │
│    ┌─────────┐    ┌─────────┐    ┌─────────┐               │
│    │  规划    │ →  │  行动   │ →  │  观察   │               │
│    │ Planning │    │  Acting │    │Observation│              │
│    └────┬────┘    └────┬────┘    └────┬────┘               │
│         │               │               │                    │
│         │          ┌─────┴─────┐        │                    │
│         │          ↓             ↓       │                    │
│         │    ┌──────────┐ ┌──────────┐  │                    │
│         │    │ 工具执行  │ │ 记忆更新  │  │                    │
│         │    └──────────┘ └──────────┘  │                    │
│         │                                   │                    │
│         └───────────────────────────────────┘                    │
│                      反馈驱动改进                                  │
└─────────────────────────────────────────────────────────────┘

---

三大核心能力

1. 规划（Planning）

规划是Agentic Reasoning的核心认知能力，使智能体能够将复杂目标分解为可执行的子步骤序列。

规划方法谱系：

方法	特点	适用场景
Chain-of-Thought	线性推理链	简单多步骤问题
Tree-of-Thought	多路径探索	需要回溯的复杂问题
Graph-of-Thought	并行图结构	有依赖关系的任务
LLM Compiler	并行规划执行	独立子任务批量处理

层次化规划结构：

class HierarchicalPlanner:
    """层次化规划器"""
    
    async def plan(self, goal: str) -> ExecutionPlan:
        # 高层规划：目标分解
        high_level = await self.decompose_goal(goal)
        
        # 中层规划：策略选择
        strategies = await self.select_strategies(high_level)
        
        # 低层规划：行动序列生成
        actions = await self.generate_actions(strategies)
        
        return ExecutionPlan(high_level, strategies, actions)
    
    async def decompose_goal(self, goal: str) -> List[Task]:
        """将高层目标分解为子任务"""
        prompt = f"""将以下目标分解为可执行的子任务：
 
目标: {goal}
 
考虑：
1. 任务之间的依赖关系
2. 哪些任务可以并行执行
3. 每个任务需要的工具或能力
 
输出子任务列表及其依赖关系。"""
        
        response = await self.llm.generate(prompt, format="json")
        return self.parse_tasks(response)

规划能力的进化：

• 单步规划：直接生成行动序列
• 迭代规划：根据执行反馈动态调整计划
• 层次规划：从抽象目标到具体行动的多层分解
• 预测规划：考虑未来状态进行前瞻性决策

2. 工具使用（Tool Use）

工具使用将LLM的能力边界从纯语言推理扩展到真实世界操作。

工具分类体系：

类别	工具示例	能力扩展
信息获取	Web Search, RAG	实时外部知识
计算执行	Code Interpreter, Calculator	精确数值计算
知识检索	Knowledge Graph, Vector DB	结构化知识访问
操作执行	File System, API Calls	物理/数字操作
验证检查	Unit Test, Formal Verifier	结果正确性保障

工具调用框架：

class ToolUsingAgent:
    def __init__(self, llm, tool_registry, max_calls=10):
        self.llm = llm
        self.tools = tool_registry
        self.max_calls = max_calls
        self.execution_trace = []
    
    async def think_and_act(self, state: str) -> tuple[str, str, Any]:
        """思考-行动循环"""
        # 推理：决定是否使用工具
        decision = await self.reason_about_action(state)
        
        if decision["action"] == "finish":
            return "finish", decision["answer"], None
        
        # 工具选择与参数生成
        tool_name = decision["tool"]
        tool_args = decision["args"]
        
        # 执行工具
        try:
            result = await self.tools.execute(tool_name, **tool_args)
            self.execution_trace.append({
                "thought": decision["thought"],
                "tool": tool_name,
                "args": tool_args,
                "result": result
            })
            return "observe", f"Tool {tool_name} returned: {result}", result
        except ToolExecutionError as e:
            return "retry", f"Tool error: {e}", None
    
    async def reason_about_action(self, state: str) -> Dict:
        """推理决定行动"""
        tool_schemas = self.tools.get_schema()
        
        prompt = f"""当前状态:
{state}
 
可用工具:
{tool_schemas}
 
根据当前状态，决定下一步行动。推理要清晰：
1. 当前知道什么？
2. 还需要什么信息？
3. 应该使用哪个工具？
4. 工具参数是什么？
 
输出JSON格式的决定。"""
        
        return await self.llm.generate(prompt, format="json")

工具使用的高级模式：

# 1. 工具链（Tool Chaining）：顺序调用多个工具
async def tool_chain(query: str, tool_sequence: List[str]):
    context = query
    for tool_name in tool_sequence:
        result = await tools.execute(tool_name, context=context)
        context = result  # 前一个工具的输出作为下一个的输入
    return context
 
# 2. 工具选择（Tool Selection）：根据上下文动态选择
async def dynamic_tool_selection(task: str):
    relevant_tools = await select_relevant_tools(task, available_tools)
    return await orchestrate_tools(relevant_tools, task)
 
# 3. 工具组合（Tool Composition）：并行/有条件地调用工具
async def composed_tools(task: str):
    branches = await analyze_parallel_opportunities(task)
    results = await asyncio.gather(*[
        execute_tool_branch(branch) for branch in branches
    ])
    return aggregate_results(results)

3. 搜索（Search）

搜索能力使智能体能够在庞大的知识空间或行动空间中找到最优或近似最优的解。

搜索范式对比：

范式	机制	优势	局限
BFS/DFS	结构化遍历	可预测、有界	可能指数爆炸
Heuristic	启发式引导	高效	可能错过最优解
MCTS	蒙特卡洛树搜索	平衡探索/利用	计算密集
Retrieval	向量相似度搜索	知识增强	依赖检索质量
LLM-Guided	LLM引导搜索	语义理解强	推理开销大

Agentic Search框架：

class AgenticSearchAgent:
    """结合LLM推理的智能搜索智能体"""
    
    def __init__(self, llm, search_engine, memory):
        self.llm = llm
        self.search = search_engine
        self.memory = memory
    
    async def search_with_reasoning(self, query: str, mode="iterative"):
        """
        带推理的搜索：
        1. 分析查询，生成搜索策略
        2. 执行搜索
        3. 评估结果，决定是否继续搜索
        """
        results = []
        iteration = 0
        max_iterations = 5
        
        # 初始查询生成
        search_queries = await self.generate_search_queries(query)
        
        while iteration < max_iterations:
            # 并行搜索
            search_results = await asyncio.gather(*[
                self.search.search(q) for q in search_queries
            ])
            
            # 推理：评估搜索结果
            evaluation = await self.evaluate_results(query, search_results)
            
            if evaluation["sufficient"]:
                results.extend(evaluation["relevant"])
                break
            
            # 推理：生成新的搜索查询
            search_queries = await self.refine_queries(
                query, 
                search_results, 
                evaluation["gaps"]
            )
            
            results.extend(evaluation["relevant"])
            iteration += 1
        
        # 存储搜索经验
        await self.memory.store_search_experience(query, results)
        
        return self.synthesize_results(query, results)
    
    async def generate_search_queries(self, query: str) -> List[str]:
        """生成多个搜索查询以覆盖不同方面"""
        prompt = f"""分析以下查询，生成3-5个不同的搜索查询来全面回答：
 
查询: {query}
 
要求：
1. 每个查询覆盖不同角度
2. 使用不同的关键词组合
3. 考虑同义词和变体表达
 
输出查询列表。"""
        
        response = await self.llm.generate(prompt)
        return self.parse_queries(response)

---

自适应能力

反馈驱动改进（Feedback-Driven Improvement）

Agentic Reasoning通过多层次反馈机制实现持续改进：

class FeedbackDrivenAgent:
    """反馈驱动的自适应智能体"""
    
    def __init__(self, llm, evaluator):
        self.llm = llm
        self.evaluator = evaluator
        self.adaptation_history = []
    
    async def run_with_feedback(self, task: str) -> str:
        """带反馈的执行循环"""
        state = {"task": task, "context": [], "iterations": 0}
        
        while state["iterations"] < self.max_iterations:
            # 1. 基于当前状态生成行动
            action = await self.decide_action(state)
            
            # 2. 执行行动
            result = await self.execute(action)
            state["context"].append({"action": action, "result": result})
            
            # 3. 评估结果
            evaluation = await self.evaluator.evaluate(task, result)
            
            # 4. 生成反馈
            if not evaluation["success"]:
                feedback = await self.generate_feedback(
                    task, action, result, evaluation
                )
                state["context"].append({"feedback": feedback})
                
                # 5. 根据反馈调整策略
                await self.adapt_strategy(feedback)
            
            state["iterations"] += 1
            
            if evaluation["success"]:
                break
        
        return self.synthesize_final_answer(state)
    
    async def generate_feedback(self, task, action, result, evaluation) -> str:
        """生成结构化反馈"""
        prompt = f"""分析执行结果，生成改进反馈：
 
任务: {task}
行动: {action}
结果: {result}
评估: {evaluation}
 
请从以下角度分析：
1. 哪里做得好？
2. 哪里出了问题？
3. 如何改进？
 
用简洁的语言总结。"""
        
        return await self.llm.generate(prompt)

反馈类型：

类型	来源	作用
执行反馈	工具返回结果	验证行动有效性
环境反馈	状态变化	指导下一步行动
自评反馈	LLM自我评估	识别推理错误
外部反馈	人类或系统	提供额外标准
任务反馈	任务完成度	评估整体效果

记忆驱动适应（Memory-Driven Adaptation）

记忆系统使智能体能够跨越长推理链保持上下文一致性，并从历史经验中学习：

class MemoryDrivenAgent:
    """记忆驱动的自适应智能体"""
    
    def __init__(self, llm):
        self.llm = llm
        self.memory = MemorySystem()
    
    async def reason_with_memory(self, query: str) -> str:
        # 1. 检索相关记忆
        relevant_memories = await self.memory.retrieve(query, k=5)
        
        # 2. 构建带记忆的上下文
        context = self.build_context(query, relevant_memories)
        
        # 3. 推理
        response = await self.llm.generate(context)
        
        # 4. 存储新的经验
        await self.memory.store({
            "query": query,
            "response": response,
            "timestamp": time.time()
        })
        
        return response
 
class MemorySystem:
    """多层次记忆系统"""
    
    def __init__(self):
        # 工作记忆：当前任务上下文
        self.working_memory = WorkingMemory()
        
        # 情景记忆：具体经验
        self.episodic_memory = EpisodicMemory()
        
        # 语义记忆：抽象知识
        self.semantic_memory = SemanticMemory()
        
        # 程序记忆：技能和流程
        self.procedural_memory = ProceduralMemory()
    
    async def retrieve(self, query: str, k: int = 5) -> List[Memory]:
        """跨层次记忆检索"""
        # 并行检索各层记忆
        results = await asyncio.gather(
            self.working_memory.search(query, k),
            self.episodic_memory.search(query, k),
            self.semantic_memory.search(query, k)
        )
        
        # 合并并重排序
        all_memories = [r for layer in results for r in layer]
        return self.rerank(all_memories, query)
    
    async def store(self, experience: Dict):
        """经验存储"""
        # 工作记忆：直接存储
        self.working_memory.add(experience["query"])
        
        # 情景记忆：向量化存储
        embedding = await self.encode(experience)
        self.episodic_memory.add(embedding, experience)
        
        # 语义记忆：提取并存储知识
        knowledge = await self.extract_knowledge(experience)
        self.semantic_memory.add(knowledge)

Mind-Map Agent 创新：

Wu & Zhu (2025) 在ACL 2025论文中提出的 Mind-Map Agent 是Agentic Reasoning的重要创新。该框架通过构建结构化知识图谱来存储推理上下文和追踪逻辑关系，有效解决了长推理链中的一致性问题。²

┌─────────────────────────────────────────────────────────────┐
│                    Mind-Map Agent 架构                       │
│                                                             │
│    用户查询 → 推理节点1 → 推理节点2 → 推理节点3 → 答案       │
│       ↓            ↓            ↓            ↓              │
│    [起始节点]    [工具调用]    [结果整合]    [最终推理]       │
│                     ↓                                       │
│              ┌─────────────────┐                            │
│              │   知识图谱层     │                            │
│              │                  │                            │
│              │  ● ── 依赖 ── ●  │                            │
│              │  │              │  │                          │
│              │  ↓              ↓  │                          │
│              │  ● ── 逻辑 ── ●  │                           │
│              │                  │                           │
│              └─────────────────┘                            │
│                                                             │
│    关键创新：通过知识图谱追踪推理链中的逻辑关系               │
└─────────────────────────────────────────────────────────────┘

---

集体协调：多智能体协作机制

单智能体到多智能体

当任务复杂度超越单智能体能力边界时，需要引入多智能体协作：

class MultiAgentCoordinator:
    """多智能体协调器"""
    
    def __init__(self, agents: Dict[str, Agent], shared_memory: SharedMemory):
        self.agents = agents
        self.shared_memory = shared_memory
    
    async def collaborative_solve(self, task: str) -> str:
        """协作式问题解决"""
        
        # 1. 任务分析与智能体分配
        subtasks = await self.analyze_and_decompose(task)
        agent_assignments = await self.assign_agents(subtasks)
        
        # 2. 协作执行
        results = await self.execute_collaboratively(
            agent_assignments,
            coordination_protocol="hierarchical"  # 或 "debate" / "collaborative"
        )
        
        # 3. 结果整合
        return await self.integrate_results(results)
    
    async def execute_collaboratively(
        self, 
        assignments: Dict[Agent, List[Subtask]], 
        coordination_protocol: str
    ) -> Dict[Agent, str]:
        """根据协调协议执行"""
        
        if coordination_protocol == "hierarchical":
            return await self.hierarchical_execution(assignments)
        elif coordination_protocol == "debate":
            return await self.debate_execution(assignments)
        elif coordination_protocol == "collaborative":
            return await self.collaborative_execution(assignments)
    
    async def hierarchical_execution(self, assignments):
        """层次化执行：Supervisor分配任务给子智能体"""
        supervisor = self.agents["supervisor"]
        subtasks = list(assignments.items())
        
        results = {}
        for agent, task_list in subtasks:
            if agent.name == "supervisor":
                continue
            
            # Supervisor分配任务
            instruction = supervisor.assign(task_list)
            
            # 子智能体执行
            result = await agent.execute(instruction)
            results[agent] = result
            
            # Supervisor评估并决定下一步
            evaluation = supervisor.evaluate(result)
            if not evaluation["satisfactory"]:
                # 重新分配或修正
                pass
        
        return results
    
    async def debate_execution(self, assignments):
        """辩论式执行：多个智能体提出方案并辩论"""
        agents = list(assignments.keys())
        
        proposals = []
        for agent in agents:
            proposal = await agent.propose(self.shared_memory.get_context())
            proposals.append(proposal)
        
        # 辩论轮次
        for round in range(self.max_debate_rounds):
            # 各智能体评论他人提案
            critiques = await asyncio.gather(*[
                agent.critique(proposals, exclude_self=True) 
                for agent in agents
            ])
            
            # 综合反馈，更新提案
            proposals = await asyncio.gather(*[
                agent.revise(proposal, critiques) 
                for agent, proposal in zip(agents, proposals)
            ])
        
        # 最终裁决
        return await self.arbitrate_final(proposals)

多智能体协调模式

模式	描述	适用场景
层次化（Hierarchical）	Supervisor协调多个专业子智能体	复杂多领域任务
辩论式（Debate）	多智能体提出方案、相互批评	需要多角度分析的问题
协作式（Collaborative）	智能体共享信息、共同解决	需要多源知识整合
竞争式（Competitive）	多个智能体竞争，优胜者主导	资源分配、方案选择
市场式（Market）	智能体作为生产者/消费者交易	任务分配、负载均衡

集体智能的关键要素

class CollectiveIntelligence:
    """集体智能框架"""
    
    def __init__(self, agent_system):
        self.agents = agent_system.agents
        self.shared_knowledge = agent_system.shared_knowledge
        self.communication_protocol = agent_system.comm_protocol
    
    async def share_knowledge(self, agent_id: str, knowledge: Dict):
        """知识共享机制"""
        # 贡献者的知识编码
        encoded = await self.encode_knowledge(knowledge)
        
        # 更新共享知识库
        await self.shared_knowledge.add(agent_id, encoded)
        
        # 广播给其他智能体
        await self.broadcast(agent_id, "knowledge_update", knowledge)
    
    async def resolve_conflicts(self, conflicting_knowledge: List[Dict]) -> Dict:
        """冲突解决机制"""
        prompt = f"""解决以下知识冲突，选择最可靠的信息源：
 
{chr(10).join([str(k) for k in conflicting_knowledge])}
 
考虑：
1. 信息来源的可靠性
2. 证据的充分性
3. 逻辑一致性
4. 最新性
 
输出解决后的知识表示。"""
        
        return await self.llm.generate(prompt)

---

实现方式：上下文编排 vs 后训练

Agentic Reasoning可以通过两种互补的方式实现，它们代表了对模型能力的不同优化路径。¹

上下文编排（In-Context Orchestration）

核心思想：在推理时（inference-time）通过提示工程和结构化编排来实现Agentic Reasoning。

class InContextAgenticReasoning:
    """上下文编排实现"""
    
    def __init__(self, base_llm):
        self.llm = base_llm
        self.tools = ToolRegistry()
        self.memory = InContextMemory()
    
    def build_orchestration_prompt(
        self,
        task: str,
        tool_descriptions: str,
        context: str,
        examples: List[Example] = None
    ) -> str:
        """构建编排提示"""
        
        system_prompt = f"""你是一个Agentic Reasoning智能体，具备以下能力：
1. 规划：将复杂任务分解为可执行步骤
2. 工具使用：调用外部工具获取信息或执行操作
3. 记忆：利用历史上下文进行连贯推理
4. 反思：评估行动结果并调整策略
 
可用工具：
{tool_descriptions}
 
推理格式：
- 思考（Thought）：分析当前状态，决定下一步
- 行动（Action）：选择并执行工具
- 观察（Observation）：分析工具返回结果
- 反思（Reflection）：评估是否需要调整策略
 
继续此循环直到任务完成。"""
        
        user_prompt = f"""
任务：{task}
 
上下文：
{context}
 
现在开始推理。"""
        
        return f"System: {system_prompt}\n\nUser: {user_prompt}"
    
    async def run(self, task: str) -> str:
        """推理时执行"""
        context = ""
        
        for step in range(self.max_steps):
            prompt = self.build_orchestration_prompt(
                task, 
                self.tools.get_descriptions(),
                context
            )
            
            response = await self.llm.generate(prompt)
            
            # 解析响应
            parsed = self.parse_response(response)
            
            if parsed["type"] == "finish":
                return parsed["answer"]
            
            # 执行工具
            if parsed["type"] == "action":
                result = await self.tools.execute(
                    parsed["tool"],
                    **parsed["args"]
                )
                context += f"\nStep {step+1}: {parsed['thought']}\n"
                context += f"Action: {parsed['tool']}({parsed['args']})\n"
                context += f"Result: {result}\n"
        
        return "达到最大步数限制"

优势：

• 无需额外训练，适用于任何LLM
• 灵活可控，易于调试
• 可动态组合不同工具和策略

局限：

• 上下文长度限制（CTX Length）
• 每次推理的计算开销
• 依赖LLM的上下文学习能力

后训练（Post-Training）

核心思想：通过有监督微调（SFT）或强化学习（RL）将Agentic Reasoning能力内化到模型中。

class PostTrainingAgenticReasoning:
    """后训练实现"""
    
    def __init__(self, base_model):
        self.model = base_model
    
    async def supervised_finetune(
        self,
        training_data: List[Trajectory],
        output_dir: str
    ):
        """
        监督微调：将Agentic Reasoning轨迹内化到模型
        """
        for trajectory in training_data:
            # 每个轨迹是一个完整的推理-行动-观察序列
            loss = 0
            for step in trajectory.steps:
                # 预测下一步的推理和行动
                logits = self.model(step.input_sequence)
                
                # 计算语言模型损失（仅在行动和响应token上）
                loss += self.compute_lm_loss(logits, step.target)
            
            loss.backward()
            
            if step % self.gradient_accumulation_steps == 0:
                self.optimizer.step()
                self.optimizer.zero_grad()
        
        self.model.save(output_dir)
    
    async def reinforcement_finetune(
        self,
        env: Environment,
        num_episodes: int
    ):
        """
        强化学习微调：通过与环境交互学习最优策略
        """
        for episode in range(num_episodes):
            trajectory = []
            
            state = env.reset()
            done = False
            
            while not done:
                # 使用当前策略采样行动
                action = await self.sample_action(state)
                
                # 执行行动
                next_state, reward, done = await env.step(action)
                
                trajectory.append({
                    "state": state,
                    "action": action,
                    "reward": reward,
                    "next_state": next_state
                })
                
                state = next_state
            
            # 使用PPO更新策略
            await self.ppo_update(trajectory)
    
    async def preference_finetune(
        self,
        trajectories: List[Trajectory],
        preferences: List[float]
    ):
        """
        偏好学习（DPO/RLHF）：学习人类偏好的推理方式
        """
        for traj, pref in zip(trajectories, preferences):
            # 计算偏好分数
            score = self.compute_preference_score(traj)
            
            # DPO损失
            chosen = traj  # 高偏好
            rejected = ...  # 低偏好轨迹
            
            loss = -log_sigmoid(score(chosen) - score(rejected))
            loss.backward()

后训练方法对比：

方法	数据需求	训练成本	泛化能力	适用场景
SFT	中等（轨迹数据）	中等	中等	固定工具集、固定流程
RL（PPO）	高（奖励信号）	高	高	需要探索的复杂任务
DPO/RLHF	高（偏好数据）	中等	高	优化推理质量和风格
GRPO	中等	中等	高	推理过程中的自我改进

两种方式的对比与融合

┌─────────────────────────────────────────────────────────────┐
│              Agentic Reasoning 实现方式谱系                    │
│                                                             │
│  纯上下文编排 ←────────────────────────────────→ 纯后训练    │
│       ↓                                              ↓      │
│  • 无需训练                                       • 能力内化  │
│  • 灵活组合                                       • 高效推理  │
│  • 上下文限制                                     • 需要数据  │
│       ↓                                              ↓      │
│  ┌─────────────────────────────────────────────────────┐   │
│  │              混合策略（主流方法）                       │   │
│  │                                                      │   │
│  │  • 基础能力：后训练内化                               │   │
│  │  • 工具使用：上下文编排                               │   │
│  │  • 动态策略：推理时选择                               │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

---

与ReAct/CoT的区别

Chain-of-Thought（CoT）

CoT的核心特征：

• 纯内部推理：通过逐步推理链生成答案，无外部交互
• 静态输入：输入固定，输出为最终答案
• 测试时计算：通过增加推理步数（test-time computation）提升性能

# CoT 示意
prompt = """问题：{question}
 
让我们逐步推理：
 
步骤1：...
步骤2：...
步骤3：...
 
最终答案：{answer}"""

ReAct（Reasoning + Acting）

ReAct的核心特征：

• 推理与行动交替：在推理过程中调用工具
• 环境反馈：工具返回结果影响后续推理
• 简单状态管理：仅跟踪当前步骤的状态

# ReAct 示意
for step in range(max_steps):
    thought = llm.think(state)        # 推理
    action = llm.select_tool(thought) # 选择工具
    result = tools.execute(action)     # 执行
    state += f"观察: {result}"         # 更新状态

Agentic Reasoning 的超越

维度	CoT	ReAct	Agentic Reasoning
推理范围	仅内部	内部+简单工具	内部+复杂工具+多系统
记忆能力	无	无	多层记忆系统
自适应能力	无	有限（依赖工具反馈）	强（反馈+反思+学习）
协作能力	无	无	多智能体协作
规划深度	无/简单链	简单线性	层次化/动态规划
长期目标	不支持	不支持	支持
错误恢复	无	有限	完整恢复机制
知识整合	训练知识	训练+工具知识	训练+工具+记忆+协作

关键差异详解

1. 记忆与上下文

• CoT：无记忆，每次推理独立
• ReAct：仅保留当前会话的简单历史
• Agentic Reasoning：完整的多层记忆系统，支持跨会话知识复用

# Agentic Reasoning 的记忆增强推理
async def reason_with_memory(query):
    # 检索相关记忆
    memories = await memory.retrieve(query)
    
    # 构建增强上下文
    context = f"相关经验：{memories}\n当前查询：{query}"
    
    # 带记忆的推理
    response = await llm.reason(context)
    
    # 存储新经验
    await memory.store(query, response)

2. 自我反思与改进

• CoT：按固定模式推理，无反思
• ReAct：工具失败时简单重试
• Agentic Reasoning：显式反思机制，分析失败原因，调整策略

# Agentic Reasoning 的反思机制
async def reflect_on_failure(task, action, result, error):
    reflection = await llm.reflect(f"""
        任务：{task}
        行动：{action}
        结果：{result}
        错误：{error}
        
        分析：
        1. 为什么失败？
        2. 什么被忽略了？
        3. 如何改进？
    """)
    
    # 基于反思生成改进策略
    improved_strategy = await generate_improved_strategy(reflection)
    return improved_strategy

3. 协作与集体智能

• CoT：单模型独立推理
• ReAct：单智能体工具使用
• Agentic Reasoning：多智能体协作，集体解决问题

总结对比表

特性	CoT	ReAct	Agentic Reasoning
适用场景	数学、逻辑问题	简单问答+工具	复杂开放任务
计算成本	中等	中等	较高
实现复杂度	低	中等	高
可扩展性	低	中等	高
自主程度	低	中	高
典型应用	数学推理、代码生成	简单问答、检索	深度研究、自动化工作流

---

关键论文和参考文献

核心论文

本综述沿着三个互补维度组织Agentic Reasoning研究：

• 基础层：规划、工具使用、搜索
• 自适应层：反馈驱动改进、记忆驱动适应
• 协作层：多智能体协调

区分了上下文编排（in-context orchestration）与后训练（post-training）两种实现路径。¹

提出Mind-Map Agent，通过结构化知识图谱存储推理上下文，追踪逻辑关系，保证长推理链的一致性。集成Web Search、Code Execution和Structured Memory三大工具。²

将Agentic LLM定义为具备三大能力的LLM：(1) 推理（Reasoning），(2) 行动（Acting），(3) 交互（Interacting）。按此三分类组织文献，提供研究议程。

ReAct的原创论文，首次提出将推理与行动结合的框架，是Agentic Reasoning的重要基础。

相关技术论文

全面综述LLM推理研究的发展脉络，从独立推理到Agentic Reasoning的演进趋势。

提出多路径探索的规划方法，对Agentic Reasoning的规划能力有重要贡献。

提出通过语言反馈实现自我改进的机制，是Agentic Reasoning自适应能力的重要基础。

展示基于LLM的智能体如何在开放环境中持续学习，是具身智能体的重要代表。

相关词条

• Agentic AI 基础 — 智能体AI的全面介绍
• Agent 架构模式 — ReAct、Plan-and-Execute、Reflexion等架构详解
• CoT (Chain-of-Thought) — 链式推理技术
• LLM Reasoning — 大语言模型推理综述
• 工具使用 — Agent工具调用机制

---

附录：快速参考

Agentic Reasoning 核心组件速查

┌─────────────────────────────────────────────────────────────┐
│                   Agentic Reasoning 组件                     │
│                                                             │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │   规划模块   │  │  工具模块   │  │   搜索模块   │         │
│  │  Planning   │  │ Tool Use   │  │   Search    │         │
│  │             │  │             │  │             │         │
│  │ • 任务分解  │  │ • 工具选择  │  │ • 搜索策略  │         │
│  │ • 策略选择  │  │ • 参数生成  │  │ • 结果评估  │         │
│  │ • 计划执行  │  │ • 结果解析  │  │ • 查询优化  │         │
│  └─────────────┘  └─────────────┘  └─────────────┘         │
│           │              │               │                 │
│           └──────────────┼───────────────┘                 │
│                          ↓                                  │
│              ┌─────────────────────┐                      │
│              │     自适应模块        │                      │
│              │  Adaptive Layer      │                      │
│              │                     │                      │
│              │  • 反馈整合          │                      │
│              │  • 记忆驱动适应      │                      │
│              │  • 策略改进          │                      │
│              └──────────┬──────────┘                      │
│                         ↓                                  │
│              ┌─────────────────────┐                      │
│              │     协作模块         │                      │
│              │  Coordination Layer │                      │
│              │                     │                      │
│              │  • 多智能体协调      │                      │
│              │  • 知识共享          │                      │
│              │  • 集体决策          │                      │
│              └─────────────────────┘                      │
└─────────────────────────────────────────────────────────────┘

关键术语对照

英文	中文	说明
Agentic Reasoning	智能体推理	推理作为智能体核心机制
In-Context Orchestration	上下文编排	推理时结构化编排
Post-Training	后训练	微调内化能力
Mind-Map Agent	思维导图智能体	知识图谱增强推理
Feedback-Driven	反馈驱动	基于反馈自适应
Collective Intelligence	集体智能	多智能体协作

Footnotes

1. Agentic Reasoning for Large Language Models — 全面综述，2026年1月。arXiv:2601.12538 ↩ ↩² ↩³ ↩⁴

2. Agentic Reasoning: A Streamlined Framework for Enhancing LLM Reasoning with Agentic Tools — Wu & Zhu, ACL 2025 (Long Paper) ↩ ↩²