Agent 设计模式
本文档整理主流 Agent 设计模式，帮助选择合适的架构。
核心模式概览
| 模式 | 核心思想 | 适用场景 | 复杂度 |
|---|---|---|---|
| ReAct | 推理 + 行动循环 | 工具调用、信息检索 | 中 |
| Reflexion | 自我反思改进 | 复杂任务、代码生成 | 高 |
| Plan-and-Execute | 先规划后执行 | 多步骤任务 | 中 |
| Tool Use | 专注工具调用 | API 集成、数据处理 | 低 |
| Multi-Agent | 多 Agent 协作 | 大型复杂系统 | 高 |
模式 1：ReAct（Reasoning + Acting）
核心思想
将推理（Reasoning）和行动（Acting）交替进行，通过"思考-行动-观察"循环解决问题。
工作流程
txt
┌─────────────────────────────────────────────────────┐
│ ReAct 循环 │
├─────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 思考 │ → │ 行动 │ → │ 观察 │ │
│ │ Thought │ │ Action │ │Observe │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ ↑ │ │
│ └───────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────┘实现示例
python
class ReActAgent:
def __init__(self, model, tools):
self.model = model
self.tools = tools
self.max_iterations = 10
def run(self, question: str) -> str:
context = f"Question: {question}\n"
for i in range(self.max_iterations):
# 1. 思考阶段
thought = self.model.generate(
context + "\nThought:",
stop=["Action:"]
)
context += f"\nThought: {thought}"
# 2. 判断是否需要行动
if "I know the answer" in thought or "Final Answer:" in thought:
return self._extract_answer(thought)
# 3. 行动阶段
action = self.model.generate(
context + "\nAction:",
stop=["Observation:"]
)
context += f"\nAction: {action}"
# 4. 执行工具
observation = self._execute_action(action)
context += f"\nObservation: {observation}"
return "Max iterations reached without answer"
def _execute_action(self, action: str) -> str:
"""执行工具调用"""
tool_name, tool_input = self._parse_action(action)
if tool_name in self.tools:
return self.tools[tool_name].run(tool_input)
return f"Unknown tool: {tool_name}"
def _extract_answer(self, text: str) -> str:
"""提取最终答案"""
if "Final Answer:" in text:
return text.split("Final Answer:")[-1].strip()
return text最佳实践
yaml
ReAct 配置建议:
最大迭代次数: 5-10
思考引导:
- 我需要先了解...
- 让我搜索一下...
- 根据观察结果...
- 我现在可以回答了...
工具设计:
- 每个工具只做一件事
- 输出格式清晰
- 包含错误处理
停止条件:
- 找到最终答案
- 达到最大迭代次数
- 连续失败 3 次适用场景
- ✅ 需要外部信息检索的任务
- ✅ 需要多步推理的任务
- ✅ 工具调用场景
- ❌ 简单问答（过度设计）
- ❌ 实时性要求极高的场景
模式 2：Reflexion（自我反思）
核心思想
让 Agent 在执行后进行自我反思，根据反思结果改进后续尝试。
工作流程
txt
┌─────────────────────────────────────────────────────┐
│ Reflexion 循环 │
├─────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 执行 │ → │ 反思 │ → │ 改进 │ │
│ │ Execute │ │Reflect │ │ Improve │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ ↑ │ │ │
│ └──────────────┴─────────────┘ │
│ │
└─────────────────────────────────────────────────────┘实现示例
python
class ReflexionAgent:
def __init__(self, model, max_attempts=3):
self.model = model
self.max_attempts = max_attempts
def run(self, task: str) -> tuple[str, list]:
memory = []
for attempt in range(self.max_attempts):
# 1. 执行任务
result = self._execute(task, memory)
# 2. 评估结果
evaluation = self._evaluate(task, result)
if evaluation["success"]:
return result, memory
# 3. 反思失败原因
reflection = self._reflect(task, result, evaluation)
memory.append({
"attempt": attempt + 1,
"result": result,
"evaluation": evaluation,
"reflection": reflection
})
return result, memory
def _execute(self, task: str, memory: list) -> str:
"""基于历史反思执行任务"""
context = f"Task: {task}\n"
if memory:
context += "\nPrevious attempts and reflections:\n"
for m in memory:
context += f"Attempt {m['attempt']}:\n"
context += f"Result: {m['result']}\n"
context += f"Issue: {m['evaluation']['issue']}\n"
context += f"Reflection: {m['reflection']}\n"
context += "\nNew attempt:"
return self.model.generate(context)
def _evaluate(self, task: str, result: str) -> dict:
"""评估执行结果"""
prompt = f"""
Task: {task}
Result: {result}
Evaluate the result:
1. Is the task completed successfully? (yes/no)
2. What is the main issue if not successful?
3. What score would you give? (0-10)
Output in JSON format.
"""
return self.model.generate_json(prompt)
def _reflect(self, task: str, result: str, evaluation: dict) -> str:
"""反思失败原因"""
prompt = f"""
Task: {task}
Result: {result}
Evaluation: {evaluation}
Reflect on why this attempt failed and what could be improved:
1. What was the root cause of the failure?
2. What assumptions were wrong?
3. What should be done differently next time?
"""
return self.model.generate(prompt)最佳实践
yaml
Reflexion 配置建议:
最大尝试次数: 3-5
反思提示:
- 为什么这次失败了？
- 哪些假设是错误的？
- 下次应该怎么做？
记忆管理:
- 只保留失败的反思
- 限制记忆条数（最近 5 次）
- 总结共同模式
适用任务:
- 代码生成
- 数学推理
- 复杂规划适用场景
- ✅ 代码生成和调试
- ✅ 数学问题求解
- ✅ 复杂推理任务
- ✅ 需要迭代的创作任务
- ❌ 简单分类任务
- ❌ 实时性要求高的场景
模式 3：Plan-and-Execute
核心思想
将复杂任务分解为计划阶段和执行阶段，先制定完整计划，再逐步执行。
工作流程
txt
┌─────────────────────────────────────────────────────┐
│ Plan-and-Execute 流程 │
├─────────────────────────────────────────────────────┤
│ │
│ 阶段 1：规划 │
│ ┌─────────────────────────────────────┐ │
│ │ 任务 → 分析 → 分解 → 计划 │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ 阶段 2：执行 │
│ ┌─────────────────────────────────────┐ │
│ │ 步骤1 → 步骤2 → 步骤3 → ... → 完成 │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ 阶段 3：验证 │
│ ┌─────────────────────────────────────┐ │
│ │ 检查结果 → 必要时重新规划 │ │
│ └─────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────┘实现示例
python
class PlanAndExecuteAgent:
def __init__(self, planner, executor, verifier):
self.planner = planner
self.executor = executor
self.verifier = verifier
def run(self, task: str) -> dict:
# 1. 规划阶段
plan = self._create_plan(task)
# 2. 执行阶段
results = []
for step in plan["steps"]:
result = self._execute_step(step, results)
results.append(result)
# 检查是否需要重新规划
if result.get("needs_replanning"):
plan = self._replan(task, results)
# 3. 验证阶段
verification = self._verify(task, results)
return {
"plan": plan,
"results": results,
"verification": verification
}
def _create_plan(self, task: str) -> dict:
"""创建执行计划"""
prompt = f"""
Task: {task}
Create a step-by-step plan to complete this task.
Each step should be:
1. Atomic (can be executed independently)
2. Verifiable (can check if completed)
3. Ordered (clear sequence)
Output as JSON with format:
{{
"steps": [
{{"id": 1, "description": "...", "tools": [...]}},
...
],
"estimated_complexity": "low|medium|high",
"dependencies": [[1, 2], [2, 3], ...]
}}
"""
return self.planner.generate_json(prompt)
def _execute_step(self, step: dict, previous_results: list) -> dict:
"""执行单个步骤"""
context = {
"step": step,
"previous_results": previous_results
}
return self.executor.execute(context)
def _verify(self, task: str, results: list) -> dict:
"""验证最终结果"""
return self.verifier.verify(task, results)
def _replan(self, task: str, results: list) -> dict:
"""重新规划"""
prompt = f"""
Task: {task}
Completed steps: {results}
The plan needs to be adjusted. Create a new plan for the remaining work.
"""
return self.planner.generate_json(prompt)最佳实践
yaml
Plan-and-Execute 配置建议:
计划粒度:
- 每个步骤可独立验证
- 单个步骤不超过 10 分钟
- 步骤之间依赖关系明确
执行策略:
- 串行执行：依赖关系复杂时
- 并行执行：独立步骤可并行
- 条件执行：根据上一步结果决定
验证检查点:
- 每个步骤完成后验证
- 关键步骤增加额外检查
- 最终结果整体验证
重规划触发:
- 步骤执行失败
- 发现新依赖
- 环境变化适用场景
- ✅ 多步骤工作流
- ✅ 项目规划
- ✅ 研究任务
- ✅ 复杂推理
- ❌ 简单单步任务
- ❌ 需要实时反馈的任务
模式 4：Tool Use（工具调用）
核心思想
专注于工具调用的模式，让 Agent 能够使用外部工具扩展能力。
工作流程
txt
┌─────────────────────────────────────────────────────┐
│ Tool Use 流程 │
├─────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ │
│ │ 用户请求 │ │
│ └────┬────┘ │
│ ↓ │
│ ┌─────────────┐ │
│ │ 解析意图 │ │
│ └────┬────────┘ │
│ ↓ │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ 选择工具 │ ←→ │ 工具注册表 │ │
│ └────┬────────┘ └─────────────┘ │
│ ↓ │
│ ┌─────────────┐ │
│ │ 执行工具 │ │
│ └────┬────────┘ │
│ ↓ │
│ ┌─────────────┐ │
│ │ 格式化响应 │ │
│ └────┬────────┘ │
│ ↓ │
│ ┌─────────┐ │
│ │ 返回结果 │ │
│ └─────────┘ │
│ │
└─────────────────────────────────────────────────────┘实现示例
python
from dataclasses import dataclass
from typing import Callable, Any
import json
@dataclass
class Tool:
name: str
description: str
parameters: dict
execute: Callable
class ToolUseAgent:
def __init__(self, model):
self.model = model
self.tools: dict[str, Tool] = {}
def register_tool(self, tool: Tool):
"""注册工具"""
self.tools[tool.name] = tool
def run(self, query: str) -> str:
"""处理用户请求"""
# 1. 获取工具描述
tools_desc = self._get_tools_description()
# 2. 让模型决定调用哪个工具
prompt = f"""
Available tools:
{tools_desc}
User query: {query}
Decide which tool to use and with what parameters.
Output in JSON format:
{{
"tool": "tool_name",
"parameters": {{...}},
"reasoning": "why this tool"
}}
If no tool is needed, output:
{{"tool": "none", "response": "direct response"}}
"""
decision = self.model.generate_json(prompt)
# 3. 执行工具或直接响应
if decision["tool"] == "none":
return decision["response"]
return self._execute_tool(decision["tool"], decision["parameters"])
def _get_tools_description(self) -> str:
"""生成工具描述"""
descriptions = []
for name, tool in self.tools.items():
desc = f"""
Tool: {name}
Description: {tool.description}
Parameters: {json.dumps(tool.parameters, indent=2)}
"""
descriptions.append(desc)
return "\n".join(descriptions)
def _execute_tool(self, tool_name: str, parameters: dict) -> str:
"""执行工具"""
if tool_name not in self.tools:
return f"Error: Unknown tool '{tool_name}'"
tool = self.tools[tool_name]
# 参数验证
validation = self._validate_parameters(tool.parameters, parameters)
if not validation["valid"]:
return f"Parameter error: {validation['error']}"
# 执行工具
try:
result = tool.execute(**parameters)
return self._format_result(result)
except Exception as e:
return f"Execution error: {str(e)}"
def _validate_parameters(self, schema: dict, params: dict) -> dict:
"""验证参数"""
required = schema.get("required", [])
properties = schema.get("properties", {})
# 检查必需参数
for param in required:
if param not in params:
return {"valid": False, "error": f"Missing required parameter: {param}"}
# 检查参数类型
for param, value in params.items():
if param in properties:
expected_type = properties[param].get("type")
# 简化类型检查
# 实际应用中应使用完整的 JSON Schema 验证
return {"valid": True}
def _format_result(self, result: Any) -> str:
"""格式化结果"""
if isinstance(result, str):
return result
return json.dumps(result, indent=2, ensure_ascii=False)工具设计最佳实践
yaml
工具设计原则:
单一职责:
- 每个工具只做一件事
- 功能边界清晰
- 命名直观
输入输出:
- 输入参数使用 JSON Schema
- 输出格式一致
- 包含错误信息
错误处理:
- 不暴露内部实现
- 提供可操作的错误信息
- 支持重试场景
安全考虑:
- 参数验证
- 权限检查
- 敏感数据脱敏
- 超时控制
工具注册示例:
- name: search_web
description: 搜索网络获取信息
parameters:
type: object
properties:
query:
type: string
description: 搜索关键词
limit:
type: integer
description: 返回结果数量
default: 5
required:
- query
- name: read_file
description: 读取本地文件内容
parameters:
type: object
properties:
path:
type: string
description: 文件路径
encoding:
type: string
description: 文件编码
default: utf-8
required:
- path适用场景
- ✅ API 集成
- ✅ 数据处理
- ✅ 文件操作
- ✅ 外部系统交互
- ❌ 纯文本生成任务
- ❌ 不需要外部能力的任务
模式 5：Multi-Agent（多 Agent 协作）
核心思想
多个 Agent 协作完成任务，每个 Agent 有特定角色和职责。
协作模式
txt
┌─────────────────────────────────────────────────────┐
│ Multi-Agent 架构 │
├─────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ │
│ │ 协调者 │ │
│ │ Coordinator │ │
│ └──────┬──────┘ │
│ │ │
│ ┌──────────────┼──────────────┐ │
│ ↓ ↓ ↓ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Agent A │ │ Agent B │ │ Agent C │ │
│ │ 研究员 │ │ 写作者 │ │ 审核员 │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ │ │ │ │
│ └──────────────┼──────────────┘ │
│ ↓ │
│ ┌─────────────┐ │
│ │ 共享记忆 │ │
│ │ Shared Mem │ │
│ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────┘实现示例
python
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Any
import queue
@dataclass
class Message:
sender: str
receiver: str
content: Any
message_type: str
class Agent(ABC):
def __init__(self, name: str, role: str):
self.name = name
self.role = role
self.inbox = queue.Queue()
@abstractmethod
def process(self, message: Message) -> list[Message]:
"""处理消息并生成响应"""
pass
def receive(self, message: Message):
"""接收消息"""
self.inbox.put(message)
class Coordinator(Agent):
def __init__(self, agents: dict[str, Agent]):
super().__init__("coordinator", "协调者")
self.agents = agents
self.task_state = {}
def process(self, message: Message) -> list[Message]:
if message.message_type == "task":
return self._decompose_task(message.content)
elif message.message_type == "result":
return self._aggregate_results(message)
return []
def _decompose_task(self, task: str) -> list[Message]:
"""分解任务"""
# 使用 LLM 分解任务
decomposition = self._llm_decompose(task)
messages = []
for subtask in decomposition["subtasks"]:
agent_name = subtask["assigned_agent"]
if agent_name in self.agents:
messages.append(Message(
sender=self.name,
receiver=agent_name,
content=subtask,
message_type="subtask"
))
return messages
def _aggregate_results(self, message: Message) -> list[Message]:
"""聚合结果"""
self.task_state[message.sender] = message.content
# 检查是否所有结果都收集完毕
if len(self.task_state) == len(self.agents):
final_result = self._llm_aggregate(self.task_state)
return [Message(
sender=self.name,
receiver="user",
content=final_result,
message_type="final_result"
)]
return []
class ResearcherAgent(Agent):
def __init__(self):
super().__init__("researcher", "研究员")
def process(self, message: Message) -> list[Message]:
# 执行研究任务
result = self._research(message.content)
return [Message(
sender=self.name,
receiver="coordinator",
content=result,
message_type="result"
)]
def _research(self, subtask: dict) -> dict:
"""执行研究"""
# 实现研究逻辑
return {"findings": "..."}
class WriterAgent(Agent):
def __init__(self):
super().__init__("writer", "写作者")
def process(self, message: Message) -> list[Message]:
# 执行写作任务
result = self._write(message.content)
return [Message(
sender=self.name,
receiver="coordinator",
content=result,
message_type="result"
)]
def _write(self, subtask: dict) -> dict:
"""执行写作"""
# 实现写作逻辑
return {"content": "..."}
class MultiAgentSystem:
def __init__(self):
self.agents = {
"researcher": ResearcherAgent(),
"writer": WriterAgent(),
}
self.coordinator = Coordinator(self.agents)
self.agents["coordinator"] = self.coordinator
def run(self, task: str) -> str:
"""运行多 Agent 系统"""
# 初始任务消息
initial_message = Message(
sender="user",
receiver="coordinator",
content=task,
message_type="task"
)
# 消息队列
message_queue = [initial_message]
while message_queue:
message = message_queue.pop(0)
receiver = self.agents.get(message.receiver)
if receiver:
responses = receiver.process(message)
message_queue.extend(responses)
if message.message_type == "final_result":
return message.content
return "Task completed without final result"最佳实践
yaml
Multi-Agent 设计原则:
角色定义:
- 每个角色有明确职责
- 角色之间不重叠
- 角色命名直观
协调机制:
- 中央协调者：适合简单流程
- 对等协作：适合复杂交互
- 层级结构：适合大型系统
通信设计:
- 消息格式标准化
- 通信通道可靠
- 消息队列管理
共享状态:
- 最小化共享状态
- 状态一致性保证
- 冲突解决机制
常见角色分配:
研究类任务:
- 研究员：收集信息
- 分析师：分析数据
- 写作者：撰写报告
- 审核员：质量检查
开发类任务:
- 架构师：设计系统
- 开发者：编写代码
- 测试员：测试代码
- 审查员：代码审查
创作类任务:
- 策划者：创意构思
- 创作者：内容创作
- 编辑者：内容优化
- 校对者：最终检查适用场景
- ✅ 复杂工作流
- ✅ 需要多角色协作的任务
- ✅ 大规模系统
- ✅ 需要并行处理的任务
- ❌ 简单任务（过度设计）
- ❌ 资源受限环境
模式选择指南
按任务复杂度选择
txt
简单任务（单步、低复杂度）
└── Tool Use
└── 直接工具调用
中等任务（多步、中复杂度）
├── ReAct
│ └── 需要推理 + 工具调用
└── Plan-and-Execute
└── 需要规划 + 执行
复杂任务（高复杂度、需要迭代）
├── Reflexion
│ └── 需要自我改进
└── Multi-Agent
└── 需要多角色协作按任务类型选择
| 任务类型 | 推荐模式 | 原因 |
|---|---|---|
| 信息检索 | ReAct + Tool Use | 需要搜索和推理 |
| 代码生成 | Reflexion | 需要迭代改进 |
| 研究报告 | Multi-Agent | 需要多角色协作 |
| 项目规划 | Plan-and-Execute | 需要结构化规划 |
| 数据处理 | Tool Use | 工具调用为主 |
| 复杂推理 | ReAct + Reflexion | 推理 + 反思 |
混合模式
实际应用中，常常需要组合多个模式：
yaml
复杂研究任务:
阶段1: Plan-and-Execute
- 制定研究计划
- 分配任务给不同 Agent
阶段2: Multi-Agent
- 研究员收集信息
- 分析师分析数据
- 写作者撰写报告
阶段3: Reflexion
- 审核员检查质量
- 反思改进建议
- 迭代优化报告
代码生成任务:
阶段1: Plan-and-Execute
- 分析需求
- 设计架构
- 规划实现步骤
阶段2: ReAct
- 编写代码
- 运行测试
- 修复问题
阶段3: Reflexion
- 代码审查
- 性能优化
- 重构改进最新 Agent 框架 (2026)
主流开源框架
| 框架 | 描述 | Stars | 链接 |
|---|---|---|---|
| OpenClaw | 开源 AI Agent 框架，多渠道消息、cron 调度、内存系统、MCP 集成 | 🌟 | GitHub |
| CrewAI | 多角色协作 Agent 框架，角色扮演、自主 AI Agent | 🌟🌟 | GitHub |
| AutoGen | 微软多 Agent 框架，支持下一代 LLM 应用 | 🌟🌟🌟 | GitHub |
| AG2 | AutoGen 创作者新框架，开源 AI Agent 编程框架，支持多 Agent 协作 | 🌟🌟 | GitHub |
| LangGraph | LangChain 的 Agent 图框架，构建有状态、多 Agent 应用 | 🌟🌟 | GitHub |
| MetaGPT | 多 Agent 元编程框架，一行需求返回 PRD、设计、代码 | 🌟🌟 | GitHub |
| OpenHands | AI 驱动的软件开发平台（原 OpenDevin） | 🌟🌟 | GitHub |
| e2b | AI Agent 沙盒执行环境，构建和部署虚拟开发者 Agent | 🌟🌟 | GitHub |
| Swarm | OpenAI 教育性多 Agent 编排框架 | 🌟 | GitHub |
| Mastra | TypeScript AI 应用框架，快速构建 AI 功能 | 🌟🌟 | GitHub |
| Swarms | 企业级多 Agent 编排框架 | 🌟 | GitHub |
| Strands Agents | 模型驱动的 Agent SDK，几行代码构建 AI Agent | 🌟 | GitHub |
| AgentUp | 安全、可扩展的 Agent 框架，配置驱动、插件生态 | 🌟 | GitHub |
| VoltAgent | TypeScript Agent 框架，内置 LLM 可观测性 | 🌟 | GitHub |
| PraisonAI | 生产级多 Agent 框架，自反思、MCP 集成、100+ LLM 支持 | 🌟 | GitHub |
| Ailoy | 全面 Agent 框架，本地 AI 和 WASM 支持 | 🌟 | GitHub |
| Hive | 目标驱动自进化 Agent 框架，自然语言定义任务、100+ 内置工具 | 🌟 | GitHub |
| FIM Agent | Python async 框架，动态 DAG 规划、ReAct agent、MCP 客户端、RAG | 🌟 | GitHub |
| NeuroLink | TypeScript Agent 框架，多步 agentic loops、持久化内存、HITL 工作流 | 🌟 | GitHub |
Agent 开发工具
| 工具 | 描述 | 链接 |
|---|---|---|
| Steel Browser | 开源浏览器自动化平台，专为 AI Agent 设计，支持无头浏览、智能等待 | GitHub |
| VibeGrid | AI 编码代理终端管理器，多代理网格布局、任务队列、工作流自动化 | GitHub |
| Dorothy | 桌面应用，同时编排多个 AI CLI agents (Claude Code, Codex, Gemini) | GitHub |
| Greywall | AI Agent 安全沙箱，deny-by-default 权限控制、受限文件系统访问 | GitHub |
| hcom | AI Agent 跨终端通信，Claude Code、Gemini CLI、Codex、OpenCode | GitHub |
| nanobot | HKUDS 超轻量级个人 AI 助手框架 (~4K 行 Python)，MCP、9+ 聊天通道 | GitHub |
| Voice Lab | 语音 Agent 测试评估框架，跨 LLM、提示、角色测试 | GitHub |
| Arize-Phoenix | Agent 测试、评估、可观测性开源库 | GitHub |
| Manifest | Agent 实时成本可观测性平台，28+ LLM 模型、本地仪表板 | GitHub |
Agent 模板资源
| 资源 | 描述 | 链接 |
|---|---|---|
| Awesome OpenClaw Agents | 100+ 生产级 SOUL.md Agent 模板，覆盖生产力、开发、营销 | GitHub |
参考来源
- ReAct: https://arxiv.org/abs/2210.03629
- Reflexion: https://arxiv.org/abs/2303.11366
- Toolformer: https://arxiv.org/abs/2302.04761
- AutoGPT: https://arxiv.org/abs/2306.02224
- BabyAGI: https://github.com/yoheinakajima/babyagi
- Awesome Agents: https://github.com/kyrolabs/awesome-agents