摘要

Agent是大模型从"对话工具"到"自主工作者"的跃升。本文从Agent架构、规划与推理、工具调用、记忆与状态、多Agent协作、失败模式与边界六个切口，给出源码级实现与企业级Agent决策框架。

1. Agent架构：感知规划行动闭环

Agent在环境中自主感知、规划、行动、观察反馈，形成闭环。核心组件：LLM大脑、规划器、工具集、记忆、执行器。

# 来源：ReAct Agent / 2023
class Agent:
    """自主智能体"""
    def __init__(self, llm, tools, memory):
        self.llm = llm
        self.tools = tools        # 可用工具集
        self.memory = memory      # 记忆模块

    def run(self, task, max_steps=20):
        """Agent 主循环"""
        self.memory.add('task', task)
        for step in range(max_steps):
            # 1. 规划: 决定下一步
            plan = self.llm.generate(self._prompt(task, step))
            # 2. 解析动作
            action = self._parse_action(plan)
            if action['type'] == 'finish':
                return action['result']
            # 3. 执行工具
            observation = self.tools[action['tool']](**action['args'])
            # 4. 观察存入记忆
            self.memory.add('observation', observation)
        return "达到最大步数"

    def _prompt(self, task, step):
        history = self.memory.get_history()
        return f"任务: {task}\n历史: {history}\n步数: {step}\n思考+动作:"

# 量化: Agent vs 单轮LLM
   # 复杂任务成功率: Agent 70-85% vs 单轮 30-50%
   # 关键: 闭环反馈使错误可纠正

量化：复杂任务成功率Agent 70-85% vs 单轮LLM 30-50%。闭环反馈使错误可纠正。

边界：步数爆炸——复杂任务步数过多延迟高。错误累积——单步错误传播放大。工具调用失败——外部API不稳定。成本高——多轮LLM调用token消耗大。死循环——Agent可能重复无效动作。

2. 规划与推理：ReAct与思维树

规划是Agent核心能力。代表：ReAct（推理+行动交替）、ToT（思维树搜索）、Reflexion（自我反思）。

# 来源：ReAct + Reflexion / 2023
class ReflexionAgent:
    """反思Agent: 失败后自我改进"""
    def __init__(self, llm, tools, memory):
        self.llm = llm
        self.tools = tools
        self.memory = memory
        self.reflections = []

    def run(self, task, max_trials=3):
        """多次尝试+反思"""
        for trial in range(max_trials):
            result = self._attempt(task)
            if result['success']:
                return result
            # 失败后反思
            reflection = self.llm.generate(
                f"任务: {task}\n尝试: {result['trace']}\n失败原因分析+改进:"
            )
            self.reflections.append(reflection)
        return result

    def _attempt(self, task):
        """单次ReAct尝试"""
        trace = []
        for step in range(15):
            thought_action = self.llm.generate(
                f"任务: {task}\n反思: {self.reflections}\n历史: {trace}\n思考+动作:"
            )
            trace.append(thought_action)
            action = self._parse(thought_action)
            if action['type'] == 'finish':
                return {'success': True, 'trace': trace, 'result': action['result']}
            obs = self.tools[action['tool']](**action['args'])
            trace.append(f"观察: {obs}")
        return {'success': False, 'trace': trace}

# 量化: 规划方法效果 (HumanEval/复杂任务)
   # 单轮: 30-50%
   # ReAct: 60-75%
   # ToT: 70-85% (搜索成本高)
   # Reflexion: 75-90% (反思有效)

量化：规划方法效果——单轮30-50%，ReAct 60-75%，ToT 70-85%（搜索成本高），Reflexion 75-90%（反思有效）。

边界：ReAct线性规划难回溯——走错路难纠正。ToT搜索成本高——分支多token爆炸。Reflexion反思可能无效——错误诊断不准。Plan-and-Execute计划可能过时——执行中环境变化。长程规划能力弱——超过10步规划质量下降。

3. 工具调用：函数调用工程化

工具调用使Agent能操作外部世界。OpenAI Function Calling标准化了工具调用接口。

# 来源：Function Calling / OpenAI 2023
import json

class ToolCaller:
    """工具调用引擎"""
    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = tools  # {name: (func, schema)}

    def call(self, user_input):
        """自动选择并调用工具"""
        # 1. LLM 决定调用哪个工具
        tool_schemas = [t[1] for t in self.tools.values()]
        response = self.llm.chat(
            user_input,
            tools=tool_schemas,  # 提供工具schema
            tool_choice='auto',
        )
        # 2. 执行工具调用
        if response.tool_calls:
            results = []
            for call in response.tool_calls:
                func, _ = self.tools[call.name]
                result = func(**json.loads(call.arguments))
                results.append(result)
            # 3. 结果回填给LLM生成最终回答
            final = self.llm.chat(
                user_input + str(results),
                tools=tool_schemas,
            )
            return final
        return response.content

# 工具定义示例
TOOL_SCHEMAS = [{
    "name": "search_database",
    "description": "查询企业数据库",
    "parameters": {
        "type": "object",
        "properties": {"query": {"type": "string"}},
        "required": ["query"],
    }
}]

# 量化: 工具调用准确率
   # GPT-4: 90-95% 正确选择工具+参数
   # 开源7B: 70-80%
   # 关键: 工具描述清晰度决定调用准确率

量化：工具调用准确率——GPT-4 90-95%正确选择工具+参数，开源7B 70-80%。工具描述清晰度决定调用准确率。

边界：参数生成可能格式错——需约束解码或重试。工具数量多选择难——超过20个工具准确率下降。嵌套调用复杂——工具A结果需传给工具B。工具失败处理——API超时/错误需重试逻辑。安全风险——工具可能执行危险操作需权限控制。

4. 记忆与状态：短期长期记忆

Agent需记忆历史交互和长期知识。分短期记忆（上下文窗口）和长期记忆（向量数据库）。

# 来源：Agent 记忆系统 / MemGPT 2024
class AgentMemory:
    """Agent 分层记忆"""
    def __init__(self, llm, vector_db, window_size=4000):
        self.llm = llm
        self.db = vector_db             # 长期记忆
        self.window = []                # 短期记忆 (上下文)
        self.window_size = window_size
        self.scratchpad = []            # 工作记忆

    def add(self, content):
        """添加记忆"""
        self.window.append(content)
        # 窗口溢出时归档到长期记忆
        if len(str(self.window)) > self.window_size:
            self._archive()

    def _archive(self):
        """归档旧记忆到向量库"""
        summary = self.llm.generate(f"总结历史: {self.window[:50]}")
        self.db.add(summary, {'raw': self.window[:50]})
        self.window = self.window[50:] + [f"历史摘要: {summary}"]

    def recall(self, query, k=5):
        """检索相关记忆"""
        # 长期记忆检索
        long_term = self.db.search(query, k=k)
        return {'short_term': self.window, 'long_term': long_term}

# 量化: 记忆系统效果
   # 无记忆: 单次会话能力
   # 有长期记忆: 跨会话任务成功率 +30-40%
   # 关键: 记忆检索相关性决定有效性

量化：有长期记忆的Agent跨会话任务成功率+30-40%。记忆检索相关性决定有效性。

边界：上下文窗口有限——长任务历史超限。向量检索精度——语义相似非任务相关。记忆噪声——无关记忆干扰决策。记忆更新难——旧记忆失效需淘汰。隐私风险——记忆存储敏感数据需加密。

5. 多Agent协作：分工与协调

复杂任务需多Agent协作。代表：AutoGen（多Agent对话）、MetaGPT（角色分工）、CrewAI。

# 来源：AutoGen 多Agent / 2023
class MultiAgentSystem:
    """多Agent协作系统"""
    def __init__(self, agents):
        self.agents = agents  # {role: agent}

    def collaborate(self, task):
        """多Agent协作完成任务"""
        # 1. 产品经理分解任务
        plan = self.agents['pm'].run(f"分解任务: {task}")
        # 2. 开发者执行
        code = self.agents['dev'].run(f"按计划开发: {plan}")
        # 3. 测试者验证
        tests = self.agents['tester'].run(f"测试代码: {code}")
        # 4. 评审者审查
        if not tests['pass']:
            # 回到开发者修复
            code = self.agents['dev'].run(f"修复: {tests['issues']}")
        review = self.agents['reviewer'].run(f"评审: {code}")
        return {'code': code, 'review': review}

class Agent:
    def __init__(self, role, llm, tools):
        self.role = role
        self.llm = llm
        self.tools = tools
    def run(self, prompt):
        return self.llm.generate(f"你是{self.role}。{prompt}")

# 量化: 多Agent vs 单Agent
   # 软件开发任务: 多Agent 75-85% vs 单Agent 50-65%
   # 成本: 多Agent 3-5 倍 token
   # 关键: 角色清晰+协调机制决定效果

量化：软件开发任务多Agent 75-85% vs 单Agent 50-65%，成本多Agent 3-5倍token。角色清晰+协调机制决定效果。

边界：协调开销大——Agent间通信消耗token。死锁可能——Agent互相等待。角色冲突——职责重叠致混乱。错误传播——一个Agent错误影响全局。成本高——多Agent token消耗数倍于单Agent。

6. 失败模式与边界

Agent失败模式集中在规划失败、工具调用错误、死循环、记忆失效、成本失控五类。

实战复盘：某Agent在数据分析任务中陷入死循环——反复调用同一无效工具。诊断发现缺乏循环检测。引入"重复动作检测"（连续3次相同动作即终止+反思），死循环消除。教训：Agent需循环检测+步数硬限制。

实战复盘：某客服Agent单次任务消耗10万token——步数过多且每步上下文过长。引入"上下文压缩"（每5步总结历史）+“步数预算”（单任务最多15步），成本降至2万token。教训：Agent需成本预算控制。

7. 企业Agent落地决策

企业部署Agent需权衡任务复杂度、可靠性要求、成本预算。核心决策：Agent类型、工具集、监控、兜底机制。

# 来源：企业Agent监控 / 生产实践 2024
class AgentMonitor:
    """Agent 生产监控"""
    def __init__(self, budget_tokens=50000, max_steps=15):
        self.budget = budget_tokens
        self.max_steps = max_steps
        self.stats = {'tasks': 0, 'success': 0, 'fail': 0, 'human': 0}

    def check_budget(self, tokens_used, steps):
        """检查预算与步数"""
        if tokens_used > self.budget:
            return 'over_budget'
        if steps > self.max_steps:
            return 'over_steps'
        return 'ok'

    def should_escalate(self, success_rate):
        """是否转人工"""
        if success_rate < 0.5:  # 成功率低于50%
            self.stats['human'] += 1
            return True
        return False

# 量化: 企业Agent投入产出
   # 简单任务: RAG 即可 (成本低)
   # 复杂任务: Agent 成功率 70-85% (成本 3-10x RAG)
   # 关键: 兜底机制是企业落地必需

量化：简单任务RAG即可成本低，复杂任务Agent成功率70-85%但成本3-10倍RAG。兜底机制是企业落地必需。

边界：Agent可靠性仍不足——70-85%成功率非100%。关键场景需人工兜底——失败时转人工。安全敏感操作需人工确认——工具调用前审批。Agent适用边界——高重复+中等复杂度任务最佳。

总结

Agent核心在于架构闭环、规划推理、工具调用、记忆状态、多Agent协作、失败模式、企业决策七点。Agent复杂任务成功率70-85% vs 单轮30-50%。Reflexion反思使成功率75-90%。GPT-4工具调用准确率90-95%。长期记忆使跨会话成功率+30-40%。多Agent软件开发成功率75-85%但成本3-5倍。企业Agent需成本预算控制+人工兜底。选型决策：简单任务用RAG，复杂任务用Agent+反思，多角色任务用多Agent，所有生产Agent需监控+兜底+安全沙箱。