AI Agent 开发实战：架构设计与实现指南

凌晨三点，我盯着终端里那个跑了二十分钟的 Agent 任务——它卡在了无限循环里，反复调用同一个工具，像个陷入死胡同的醉汉。

这不是我第一次踩坑。过去两年做 Agent 开发，类似的翻车现场见过太多：ReAct Agent 莫名其妙陷入死循环，多代理系统像开了个吵架大会，Plan-and-Execute 模式对动态任务束手无策。

说实话，当你第一次看到 ReAct、Plan-and-Execute、Multi-Agent 这些术语时，大概率会懵——该选哪个？它们有什么区别？什么时候用单代理，什么时候必须上多代理？

这篇文章就是想把这些年的经验踩过的坑都摊开来讲清楚。我们会聊到：

• Agent 架构的三个层级，以及为什么”能用简单就别用复杂”
• ReAct、Plan-and-Execute、Multi-Agent 三种核心模式原理和代码实现
• 五种多代理编排模式：Sequential、Concurrent、Group Chat、Handoff、Magentic
• LangChain、AutoGen、CrewAI、Claude Agent SDK 怎么选
• 用 Claude Agent SDK 写一个能跑的 Agent

嗯，开整。

一、Agent 架构的三个层级

先说一个很多新手容易忽略的原则：能用简单方案解决的，别上复杂架构。

Azure 官方把 Agent 架构分成三个层级，这个分类方式特别实用：

1.1 直接调用模型（Direct Model Call）

最简单的一层。你把任务丢给模型，模型直接给你答案。

// 最基础的调用方式
const response = await anthropic.messages.create({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 1024,
  messages: [{ role: 'user', content: '帮我总结这段文本...' }]
});

适合场景：单步任务、确定性高的场景、不需要外部工具的场景。比如文本摘要、翻译、代码补全。

优点？简单、便宜、可控。缺点？无法处理需要多步推理的复杂任务，不能调用外部工具。

1.2 单代理 + 工具（Single Agent with Tools）

这是大多数企业场景的默认选择。Agent 可以调用工具，能处理多步任务。

// LangChain 单代理示例
import { ChatAnthropic } from '@langchain/anthropic';
import { AgentExecutor, createToolCallingAgent } from 'langchain/agents';
import { tool } from '@langchain/core/tools';
import { z } from 'zod';

// 定义一个查询天气的工具
const weatherTool = tool(
  async ({ city }) => {
    // 模拟天气 API 调用
    return `${city}今天晴，气温 22°C`;
  },
  {
    name: 'get_weather',
    description: '获取指定城市的天气信息',
    schema: z.object({
      city: z.string().describe('城市名称'),
    }),
  }
);

const model = new ChatAnthropic({
  model: 'claude-sonnet-4-20250514',
  temperature: 0,
});

const agent = await createToolCallingAgent({
  llm: model,
  tools: [weatherTool],
  prompt: '你是一个有用的助手。',
});

const executor = AgentExecutor.fromAgentAndTools({
  agent,
  tools: [weatherTool],
});

// 运行
const result = await executor.invoke({
  input: '北京今天天气怎么样？',
});

适合场景：需要工具调用、任务可分解、步骤相对固定的场景。比如数据分析、代码执行、API 编排。

1.3 多代理编排（Multi-Agent Orchestration）

最复杂的一层。多个专业 Agent 各司其职，协作完成任务。

说句实话，能用这一层解决问题的场景，没你想的那么多。引入多代理意味着协调开销、状态管理复杂度、调试难度都会指数级上升。

适合场景：跨领域复杂任务、需要专业分工、单一 Agent 无法胜任的场景。比如软件开发流水线（需求分析 → 设计 → 编码 → 测试）、复杂决策系统。

1.4 怎么选？一个决策表格

你的场景	推荐层级	原因
简单问答、文本处理	直接调用模型	够用了，别过度设计
需要查数据库、调 API	单代理 + 工具	经典方案，稳定性好
任务可分解但步骤不确定	单代理 + 工具（ReAct 模式）	让 Agent 自己规划步骤
需要多个专业角色协作	多代理编排	慎重，先评估是否真需要

一句话总结：从简单开始，需要什么加什么。

二、三大核心架构模式详解

确定了用哪个层级之后，接下来就是选模式。这三种模式不是互斥的——很多场景下会组合使用。

2.1 ReAct（推理-行动）模式

ReAct 是 Reasoning + Acting 的缩写，核心思想是让模型”边想边做”。

工作原理：

用户输入 → Thought（思考）→ Action（行动）→ Observation（观察）→ 循环或结束

举个例子，用户问”北京明天的天气适合户外运动吗？”：

1. Thought：我需要先查北京明天的天气
2. Action：调用 get_weather 工具，参数 city: "北京"
3. Observation：北京明天多云，气温 18-25°C，降水概率 10%
4. Thought：气温适中，降水概率低，适合户外运动
5. Final Answer：北京明天适合户外运动，建议穿轻薄外套

代码实现（LangChain）：

import { ChatAnthropic } from '@langchain/anthropic';
import { AgentExecutor, createReactAgent } from 'langchain/agents';
import { pull } from 'langchain/hub';

// ReAct prompt 模板
const prompt = await pull('hwchase17/react');

const agent = await createReactAgent({
  llm: model,
  tools: [weatherTool, searchTool], // 你的工具列表
  prompt,
});

// 设置最大迭代次数，防止无限循环！
const executor = AgentExecutor.fromAgentAndTools({
  agent,
  tools: [weatherTool, searchTool],
  maxIterations: 10, // 重要：防止死循环
  verbose: true, // 打印推理过程，调试必备
});

优缺点分析：

优点	缺点
灵活性高，能处理动态任务	可能陷入无限循环
推理过程透明，便于调试	单次调用成本较高
不需要预先定义步骤	对复杂多步任务规划能力有限

踩坑提醒：一定要设置 maxIterations，否则遇到没法完成的任务时，Agent 会一直跑下去——我第一个 ReAct Agent 就这么跑了一整夜。

2.2 Plan-and-Execute（规划-执行）模式

ReAct 的问题在于它是”走一步看一步”，遇到复杂任务容易跑偏。Plan-and-Execute 的思路是：先把计划定好，再一步步执行。

工作原理：

用户输入 → Planner（规划器）生成计划 → Executor 逐步执行 → 返回结果

代码实现（LangGraph）：

import { ChatAnthropic } from '@langchain/anthropic';
import { StateGraph, END } from '@langchain/langgraph';

// 定义状态结构
interface AgentState {
  input: string;
  plan: string[];
  pastSteps: string[];
  response: string;
}

// 规划节点：生成执行计划
async function planNode(state: AgentState): Promise<AgentState> {
  const plannerPrompt = `给定用户目标：${state.input}
请生成一个详细的执行计划，每步一个字符串，返回 JSON 数组格式。`;

  const response = await model.invoke(plannerPrompt);
  const plan = JSON.parse(response.content as string);
  return { ...state, plan };
}

// 执行节点：执行计划中的一步
async function executeNode(state: AgentState): Promise<AgentState> {
  const currentStep = state.plan[0];
  const result = await executor.invoke({ input: currentStep });

  return {
    ...state,
    plan: state.plan.slice(1), // 移除已完成的步骤
    pastSteps: [...state.pastSteps, `${currentStep}: ${result.output}`],
  };
}

// 构建图
const workflow = new StateGraph<AgentState>({
  channels: {
    input: { value: null },
    plan: { value: null },
    pastSteps: { value: null, default: () => [] },
    response: { value: null },
  },
});

workflow.addNode('planner', planNode);
workflow.addNode('executor', executeNode);

// 定义边：规划完成后执行
workflow.addEdge('planner', 'executor');

// 条件边：检查是否还有步骤
workflow.addConditionalEdges('executor', (state) => {
  return state.plan.length > 0 ? 'executor' : END;
});

优缺点分析：

优点	缺点
执行稳定，步骤可控	计划一旦生成就不灵活
适合确定性任务	动态变化的环境不适应
便于监控和中断	规划质量依赖 Planner 能力

我的使用体会：Plan-and-Execute 特别适合那些”步骤可预见”的任务，比如批量数据处理、报告生成。但对于需要频繁调整策略的任务，ReAct 反而更合适。

2.3 Multi-Agent（多代理协作）模式

当任务复杂到单 Agent 搞不定时，就得请多代理上场了。

核心思想：每个 Agent 专注于一个领域，像团队一样协作。

代码实现（Claude Agent SDK 风格）：

import { ClaudeAgent } from '@anthropic-ai/claude-agent-sdk';

// 创建专业代理
const researchAgent = new ClaudeAgent({
  name: 'researcher',
  model: 'claude-sonnet-4-20250514',
  systemPrompt: '你是一个研究专家，负责收集和整理信息。',
  tools: ['WebSearch', 'WebFetch'],
});

const writerAgent = new ClaudeAgent({
  name: 'writer',
  model: 'claude-sonnet-4-20250514',
  systemPrompt: '你是一个内容创作专家，负责撰写和润色文章。',
  tools: ['Read', 'Write', 'Edit'],
});

const reviewerAgent = new ClaudeAgent({
  name: 'reviewer',
  model: 'claude-sonnet-4-20250514',
  systemPrompt: '你是一个质量审核专家，负责检查内容的准确性和可读性。',
  tools: ['Read'],
});

// 协作流程
async function collaborativeWriting(topic: string) {
  // 第一步：研究
  const research = await researchAgent.run(`研究主题：${topic}`);

  // 第二步：写作
  const draft = await writerAgent.run(
    `基于以下研究结果，撰写一篇文章：\n${research}`
  );

  // 第三步：审核
  const review = await reviewerAgent.run(
    `审核以下文章，提出修改建议：\n${draft}`
  );

  // 第四步：修改
  const final = await writerAgent.run(
    `根据审核意见修改文章：\n原稿：${draft}\n意见：${review}`
  );

  return final;
}

何时该用多代理：

• 任务需要多种专业技能（比如编程 + 设计 + 文案）
• 单 Agent 上下文窗口不够用
• 需要专业分工，各司其职

警告：多代理的调试难度是指数级上升的。两个 Agent 之间的状态同步、消息传递、错误处理都会变得复杂。能用单代理解决的，别硬上多代理。

三、多代理编排的五种模式

如果你的场景确实需要多代理，接下来就是选编排模式。Azure 官方总结的这五种模式，基本覆盖了大部分场景。

3.1 Sequential（顺序编排）

最直观的模式：Agent A 的输出是 Agent B 的输入，像流水线一样。

[Agent A] → [Agent B] → [Agent C] → 最终结果

适用场景：文档生成流水线（调研 → 起草 → 审校 → 发布）、代码生成流程。

代码示例：

// 顺序编排示例
async function sequentialPipeline(input: string) {
  const step1 = await researchAgent.run(input);
  const step2 = await writerAgent.run(step1.output);
  const step3 = await editorAgent.run(step2.output);
  return step3.output;
}

注意点：每一步的输出格式要提前约定好，否则下游 Agent 会收到它理解不了的数据。

3.2 Concurrent（并发编排）

多个 Agent 同时处理同一个输入，最后汇总结果。

           → [Agent A] →
[输入]  →  → [Agent B] →  → [汇总器] → 最终结果
           → [Agent C] →

适用场景：多视角分析、股票评估（技术面 + 基本面 + 消息面并行分析）、代码审查（安全 + 性能 + 风格并行检查）。

代码示例：

// 并发编排示例
async function concurrentAnalysis(code: string) {
  const [security, performance, style] = await Promise.all([
    securityAgent.run(`安全审查：\n${code}`),
    performanceAgent.run(`性能分析：\n${code}`),
    styleAgent.run(`代码风格检查：\n${code}`),
  ]);

  // 汇总结果
  return {
    security: security.output,
    performance: performance.output,
    style: style.output,
  };
}

注意点：并行执行要注意结果汇总的逻辑，不同 Agent 可能有冲突的建议，需要设计仲裁机制。

3.3 Group Chat（群聊编排）

多个 Agent 在一个”聊天室”里讨论，直到达成共识或超时。

[Agent A] ⇄ [Agent B] ⇄ [Agent C]
     ↑           ↓
   [Moderator/协调者]

适用场景：头脑风暴、质量验证、需要多轮讨论才能决策的场景。

Azure 官方建议：群聊代理数量限制在 3 个以内。多了就变成吵架大会了。

代码示例：

// 群聊编排示例（伪代码示意）
interface ChatMessage {
  sender: string;
  content: string;
}

async function groupChatDiscussion(
  topic: string,
  agents: ClaudeAgent[],
  maxRounds: number = 5
) {
  const history: ChatMessage[] = [];

  for (let round = 0; round < maxRounds; round++) {
    for (const agent of agents) {
      const response = await agent.run(
        `讨论主题：${topic}\n当前对话历史：${JSON.stringify(history)}\n请发表你的观点。`
      );
      history.push({ sender: agent.name, content: response.output });

      // 检查是否达成共识
      if (checkConsensus(history)) {
        return summarizeConsensus(history);
      }
    }
  }

  return '讨论超时，未达成共识';
}

踩坑经验：一定要设置 maxRounds，否则两个固执的 Agent 可以一直争论下去。另外，最好有个 Moderator 角色，负责收敛讨论。

3.4 Handoff（移交编排）

一个 Agent 完成任务后，把工作移交给下一个 Agent。

[Agent A] 检测到需要 B 的专业能力 → 移交给 [Agent B] → 继续处理

适用场景：客服机器人（售前 → 技术支持 → 售后）、故障排查（诊断 → 修复 → 验证）。

代码示例：

// 移交编排示例
const supportAgent = new ClaudeAgent({
  name: 'support',
  systemPrompt: `你是客服。如果用户问技术问题，回复 "HANDOFF:tech"。
如果用户问售后问题，回复 "HANDOFF:after_sales"。`,
});

const techAgent = new ClaudeAgent({
  name: 'tech',
  systemPrompt: '你是技术支持专家。',
});

async function handleWithHandoff(userInput: string) {
  let currentAgent = supportAgent;
  let response = await currentAgent.run(userInput);

  // 检测移交信号
  while (response.output.includes('HANDOFF:')) {
    const targetAgent = response.output.match(/HANDOFF:(\w+)/)?.[1];

    if (targetAgent === 'tech') currentAgent = techAgent;
    else if (targetAgent === 'after_sales') currentAgent = afterSalesAgent;

    response = await currentAgent.run(userInput);
  }

  return response.output;
}

注意点：移交逻辑要清晰，避免循环移交（A 移给 B，B 又移给 A）。

3.5 Magentic（磁性编排）

最灵活的模式：根据任务性质，动态”吸引”最合适的 Agent 来处理。

[任务池] → [智能调度器] → 根据任务特点选择 [Agent A/B/C]

适用场景：任务类型多样的系统、需要动态调度资源的场景。

实现思路：

// 磁性编排示例
interface Task {
  type: string;
  priority: number;
  content: string;
}

async function magenticScheduling(task: Task) {
  // 根据任务类型选择最合适的 Agent
  const agentScores = await Promise.all(
    agents.map(async (agent) => {
      const score = await evaluateAgentFit(agent, task);
      return { agent, score };
    })
  );

  // 选择得分最高的 Agent
  const bestAgent = agentScores.sort((a, b) => b.score - a.score)[0].agent;
  return bestAgent.run(task.content);
}

注意点：需要设计好”匹配度评估”的逻辑，否则调度会变成随机分配。

3.6 模式选择速查表

模式	适用场景	复杂度	主要风险
Sequential	流水线式任务	低	步骤依赖导致阻塞
Concurrent	多视角并行分析	中	结果冲突需要仲裁
Group Chat	多轮讨论决策	高	无法收敛、无限争论
Handoff	动态分工协作	中	循环移交、移交死锁
Magentic	任务类型多样	高	调度逻辑复杂

四、主流框架对比与选型

聊完架构模式，该说说具体用哪个框架了。这块确实容易让人眼花——LangChain、AutoGen、CrewAI、Claude Agent SDK，各有各的说法。

先说我的观点：没有最好的框架，只有最适合你场景的框架。

4.1 框架定位对比

框架	核心定位	强项	适用场景
LangChain	通用 Agent 框架	工具集成丰富、ReAct 实现成熟	快速原型、生产应用、需要大量工具集成
AutoGen	多代理协作	对话式协作、人机协作	复杂多代理系统、需要人介入的场景
CrewAI	角色扮演协作	API 简洁、概念直观	团队模拟、角色分工明确的场景
Claude Agent SDK	Claude 原生	代码理解、文件操作、Claude 深度集成	Claude 生态、代码 Agent、自动化任务

4.2 各框架特点详解

LangChain：老牌选手，生态最成熟。

• TypeScript 和 Python 都有完整支持
• 内置大量工具和集成
• ReAct、Plan-and-Execute 都有现成实现
• 缺点？API 变动频繁，文档有时候跟不上

AutoGen：微软出品，多代理协作的首选。

• 核心概念是”对话”，Agent 之间通过消息传递协作
• 支持人机协作（Human-in-the-loop）
• 适合需要多轮讨论、决策的场景
• 缺点？学习曲线陡峭，调试多代理系统很痛苦

CrewAI：新秀，主打简洁。

• 用”角色”、“任务”、“团队”的概念建模，很直观
• API 设计干净，上手快
• 适合快速搭建多代理原型
• 缺点？生态和工具集成不如 LangChain 丰富

Claude Agent SDK：Anthropic 官方出品，2026 年新发布的工具。

• 与 Claude 模型深度集成
• 内置文件读写、代码编辑、命令执行能力
• 支持 permissionMode 控制操作权限
• 如果你的主力模型是 Claude，这个是首选

4.3 选型决策指南

问自己几个问题：

1. 你的主力模型是什么？

   • Claude → 优先 Claude Agent SDK
   • OpenAI → LangChain 生态更成熟
   • 多模型 → LangChain 或 AutoGen

2. 任务复杂度如何？

   • 单 Agent + 工具 → LangChain 足够
   • 多 Agent 协作 → AutoGen 或 CrewAI
   • 代码相关任务 → Claude Agent SDK

3. 团队技术栈是什么？

   • Python 为主 → 所有框架都支持
   • TypeScript 为主 → LangChain、Claude Agent SDK 支持更好

4. 你需要人机协作吗？

   • 需要 → AutoGen 的 Human-in-the-loop 设计得很好
   • 不需要 → 其他框架都行

4.4 我的选型建议

老实说，大部分场景 LangChain 就够用了。它的工具集成、ReAct 实现都很成熟，社区支持也好。

如果你确定要用多代理，而且任务确实复杂到需要多个专业 Agent 协作，AutoGen 值得一试。但记住：多代理的调试成本很高，不要为了”技术先进”而硬上。

如果你是 Claude 的重度用户，Claude Agent SDK 是目前最好的选择——毕竟是官方出品，和 Claude 模型的配合最默契。

五、实战 - 用 Claude Agent SDK 构建 Agent

说了这么多理论，来点实战。用 Claude Agent SDK 写一个能跑的代码重构 Agent。

5.1 环境准备

# 安装依赖
npm install @anthropic-ai/claude-agent-sdk

# 设置 API Key
export ANTHROPIC_API_KEY=your_api_key_here

5.2 基础 Agent 示例

import { ClaudeAgent } from '@anthropic-ai/claude-agent-sdk';

// 创建一个代码重构 Agent
const refactorAgent = new ClaudeAgent({
  model: 'claude-sonnet-4-20250514',
  tools: ['Read', 'Write', 'Edit', 'Bash'],
  permissionMode: 'acceptEdits', // 自动接受编辑操作
  workingDirectory: './src', // 工作目录
});

// 执行任务
async function refactorCode(task: string) {
  const result = await refactorAgent.run(task);
  console.log('重构结果：', result);
  return result;
}

// 使用示例
refactorCode('重构 auth.ts 文件，将回调风格的代码改为 async/await');

5.3 重要配置说明

permissionMode（权限模式）：

• 'acceptEdits'：自动接受文件编辑操作
• 'interactive'：每次操作都需要人工确认
• 'planOnly'：只生成计划，不执行

tools（可用工具）：

• Read：读取文件
• Write：创建新文件
• Edit：编辑现有文件
• Bash：执行命令行命令
• Glob：文件模式匹配
• Grep：内容搜索

5.4 更复杂的示例：带约束的 Agent

const cautiousAgent = new ClaudeAgent({
  model: 'claude-sonnet-4-20250514',
  tools: ['Read', 'Write', 'Edit', 'Bash'],
  permissionMode: 'interactive', // 谨慎模式：需要人工确认
  maxIterations: 20, // 限制最大迭代次数
  timeout: 300000, // 5 分钟超时

  // 系统提示词：定义 Agent 行为边界
  systemPrompt: `你是一个代码重构专家。
规则：
1. 不删除任何测试文件
2. 不修改 package.json
3. 每次修改前先备份原文件
4. 修改后运行测试确保功能正常`,
});

async function safeRefactor(filePath: string) {
  try {
    const result = await cautiousAgent.run(
      `请重构 ${filePath}，优化代码结构和可读性。`
    );
    return result;
  } catch (error) {
    console.error('重构失败：', error);
    // 回滚逻辑...
  }
}

5.5 最佳实践

1. 限制迭代次数：防止 Agent 陷入无限循环
2. 设置超时：长时间运行的任务要有兜底
3. 权限分级：敏感操作用 interactive 模式
4. 备份机制：重要文件修改前先备份
5. 测试验证：修改后跑测试，确保功能正常

5.6 调试技巧

// 开启详细日志
const debugAgent = new ClaudeAgent({
  model: 'claude-sonnet-4-20250514',
  tools: ['Read', 'Write', 'Edit'],
  verbose: true, // 打印详细执行过程
});

// 监听事件
debugAgent.on('toolCall', (tool, args) => {
  console.log(`调用工具：${tool}，参数：${JSON.stringify(args)}`);
});

debugAgent.on('thinking', (thought) => {
  console.log(`Agent 思考：${thought}`);
});

写在最后

说到这儿，Agent 架构选择的核心思路其实就一句话：从简单开始，需要什么加什么。

先判断你的任务复杂度：

• 单步任务？直接调模型
• 需要工具？单代理 + 工具
• 确实需要多个专业角色？再考虑多代理

然后选模式：

• 任务动态变化？ReAct
• 步骤可预见？Plan-and-Execute
• 需要专业分工？Multi-Agent

最后选框架：

• Claude 用户？Claude Agent SDK
• 多模型、多工具？LangChain
• 多代理协作？AutoGen 或 CrewAI

说了这么多，最重要的还是动手试试。找个小项目，搭个 Agent 跑起来——踩几个坑，你就懂了。

有问题欢迎在评论区讨论，或者直接去看我前两篇文章：「MCP Server 开发入门」和「Agent 工具调用实战」，这三篇是一脉相承的。

用 Claude Agent SDK 构建 Agent

从环境准备到运行第一个 Agent 的完整步骤

⏱️ 预计耗时: 30 分钟

1. 1

   步骤1: 安装依赖并配置环境

   执行以下命令：
   
   ```bash
   npm install @anthropic-ai/claude-agent-sdk
   export ANTHROPIC_API_KEY=your_api_key_here
   ```
   
   注意：API Key 需要从 Anthropic 官网获取，建议存储在环境变量中。
2. 2

   步骤2: 创建基础 Agent 实例

   创建 Agent 时需要配置三个核心参数：
   
   ```typescript
   const agent = new ClaudeAgent({
   model: 'claude-sonnet-4-20250514',
   tools: ['Read', 'Write', 'Edit', 'Bash'],
   permissionMode: 'acceptEdits'
   });
   ```
   
   • model：选择 Claude 模型版本
   • tools：指定 Agent 可用的工具
   • permissionMode：权限控制模式
3. 3

   步骤3: 执行任务并获取结果

   调用 run 方法执行任务：
   
   ```typescript
   const result = await agent.run('重构 auth.ts 文件');
   ```
   
   建议添加错误处理和日志记录。
4. 4

   步骤4: 配置安全防护

   生产环境必须设置防护措施：
   
   • maxIterations：限制最大迭代次数（推荐 20）
   • timeout：设置超时时间（推荐 5 分钟）
   • systemPrompt：定义行为边界
   • permissionMode：敏感操作使用 'interactive' 模式

常见问题

ReAct、Plan-and-Execute、Multi-Agent 三种模式怎么选？

根据任务特点选择：ReAct 适合任务步骤不确定、需要动态决策的场景（如客服问答）；Plan-and-Execute 适合步骤可预见、需要稳定输出的场景（如报告生成）；Multi-Agent 适合需要多种专业技能协作的复杂任务（如软件开发流水线）。

为什么 Azure 建议群聊代理限制在 3 个以内？

群聊代理数量过多会导致两个问题：一是讨论难以收敛，多个 Agent 可能陷入无休止的争论；二是调试成本指数级上升，Agent 之间的状态同步和消息传递变得极其复杂。3 个代理（如主持人 + 两个观点对立方）通常足以覆盖大多数需要讨论决策的场景。

LangChain 和 AutoGen/CrewAI 怎么选？

大部分场景 LangChain 就够用，它工具集成丰富、ReAct 实现成熟、社区支持好。只有当你确定需要多代理协作时，才考虑 AutoGen 或 CrewAI。AutoGen 支持人机协作（Human-in-the-loop），适合需要人工介入的场景；CrewAI API 更简洁，适合快速搭建原型。

Claude Agent SDK 适合什么场景使用？

Claude Agent SDK 是 Anthropic 官方工具，最适合三类场景：一是你的主力模型是 Claude，它与 Claude 深度集成；二是代码相关任务，它内置文件读写、代码编辑能力；三是需要精细权限控制，它的 permissionMode 可以分级管理操作权限。

如何避免 Agent 陷入无限循环？

三个关键防护措施：一、设置 maxIterations（推荐 10-20 次），超过后强制停止；二、设置 timeout（推荐 5 分钟），超时自动中断；三、在 systemPrompt 中明确终止条件，告诉 Agent 什么情况下应该放弃。我第一个 ReAct Agent 因为没设置这些，跑了一整夜。

14 分钟阅读 · 发布于: 2026年3月21日 · 修改于: 2026年3月22日