重新定义智能：AI Agent如何模拟人类行为逻辑

一、 引言 (Introduction)

1.1 钩子 (The Hook)

“贾维斯，帮我分析一下这套战甲的能耗比。”在漫威电影中，托尼·史塔克对着空气随口一句话，一个无所不能的人工智能助手便立刻开始工作：检索数据、进行计算、生成方案、甚至控制物理设备。这一幕在十年前还只是纯粹的科幻幻想，但在今天，随着大语言模型（LLMs）的爆发，一种被称为 AI Agent（智能体） 的技术正在让这一切逐步照进现实。

你是否也曾想过：为什么现在的AI能写代码、能写诗，却不能像个真正的助理那样，帮你“自动”订一张下周去北京且性价比最高的机票，并在订好后把行程同步到你的日历，甚至提醒你目的地的天气？

区别就在这里：前者是一个强大的工具，而后者，是一个具备自主决策和行动能力的Agent。

1.2 定义问题/阐述背景 (The “Why”)

在过去的深度学习时代，我们构建了无数精准的模型：它们能识别图片中的猫，能预测股票的涨跌，能翻译几十种语言。但这些模型本质上都是“被动”的——你给我一个特定格式的输入，我给你一个特定格式的输出。它们没有记忆（上下文窗口有限），没有目标（不知道为什么要做这件事），更没有工具使用能力（除非你硬编码进去）。

这就引出了一个核心问题：我们该如何构建一个系统，使其不仅“知道”很多知识，还能像人类一样，基于长期记忆、明确目标以及环境反馈，自主地规划并执行一系列复杂的行动？

这便是 AI Agent 要解决的问题。AI Agent 的核心价值，在于它试图模拟人类的行为逻辑闭环：通过感知环境信息，结合自身的知识与记忆，进行推理规划，然后调用工具执行动作，并根据结果反馈调整下一步策略，直至达成目标。这不仅仅是技术的迭代，更是对“智能”定义的重新思考。

1.3 亮明观点/文章目标 (The “What” & “How”)

本文将带你深入 AI Agent 的内核。我们不会只停留在概念介绍，而是会从认知科学的类比出发，到数学模型的构建，再到代码层面的实战拆解，全方位地剖析 AI Agent 是如何工作的。

具体来说，你将学到：

1. 核心概念： 什么是 AI Agent？它由哪些核心模块组成？
2. 理论基础： 如何用马尔可夫决策过程（MDP）和强化学习（RL）的视角看待 Agent？
3. 架构设计： 一个完整的 Agent 系统（记忆、规划、工具使用）是如何流转的？
4. 代码实战： 我们将用 Python 结合 LangChain 构建一个简化版的“研究助手” Agent。
5. 未来展望： Agent 技术目前的局限在哪里？它将如何演变？

准备好了吗？让我们开始这场通往“人工通用智能”雏形的探索之旅。

二、 基础知识/背景铺垫 (Foundational Concepts)

在深入探讨 Agent 的内部机制之前，我们必须先建立一些共识。这一章我们将回答三个问题：什么是 Agent？人类的行为逻辑可以被拆解成哪些环节？以及目前构建 Agent 有哪些主流的技术弹药？

2.1 核心概念定义：什么是 Agent？

“Agent”一词源于拉丁语“Agere”，意为“去做（to do）”。在计算机科学和人工智能领域，一个Agent通常被定义为：一个能够通过传感器感知环境，并通过执行器作用于该环境，以实现一系列目标的自主实体。

这个定义听起来有点抽象，我们可以通过一张表格来对比一下 AI Agent 与我们熟悉的其他概念的区别：

2.1.1 概念结构与核心要素组成

从最宏观的角度看，任何 Agent 系统都包含以下四个核心要素：

1. 环境 (Environment): Agent 存在并与之交互的外部世界（可以是互联网、操作系统、物理世界等）。
2. 感知 (Perception/Sensors): Agent 获取环境信息的途径（例如：读取文件、调用搜索引擎 API、摄像头数据）。
3. 决策中心 (Decision Maker): Agent 的“大脑”，处理感知信息，决定下一步做什么（这是 LLM 主要扮演的角色）。
4. 执行 (Action/Actuators): Agent 对环境施加影响的方式（例如：写文件、发邮件、点击网页按钮）。

2.2 人类行为逻辑的拆解：从 BDI 模型到 OODA 循环

AI Agent 的设计灵感很大程度上来源于对人类认知的模拟。为了理解如何构建 Agent，我们先看看人类是如何做决策的。

2.2.1 BDI 模型 (Belief-Desire-Intention)

这是由哲学家 Michael Bratman 提出的认知模型，被广泛应用于分布式 AI 和多智能体系统。

• 信念 (Belief): 个体对世界的认知（包括事实、规则和对当前状态的判断）。例如：“我相信现在是下午6点”，“我相信写代码能赚钱”。
• 愿望 (Desire): 个体希望达成的目标或偏好的状态。例如：“我想吃火锅”。
• 意图 (Intention): 在信念的基础上，为了实现愿望而选择的承诺执行的行动计划。例如：“我现在要打开手机找火锅店，选一家评分4.5以上的，然后打车过去。”

2.2.2 OODA 循环

这是由美国空军上校约翰·博伊德提出的军事决策模型，它更强调动态性和反馈：

1. 观察 (Observe): 观察环境，收集信息。
2. 判断 (Orient): 分析信息，形成对形势的判断。
3. 决策 (Decide): 基于判断，确定行动方案。
4. 行动 (Act): 执行方案，并回到“观察”阶段，查看结果。

如果你把这两个模型结合起来看，其实就是现代 AI Agent 的基本运行逻辑：拥有知识（Belief），设定目标（Desire），然后通过观察-判断-决策-行动的循环（OODA）来兑现意图（Intention）。

2.3 相关工具/技术概览

要构建一个现代的 AI Agent，你通常需要以下技术栈的组合：

2.3.1 核心大脑：LLMs (大语言模型)

这是 Agent 的“中央处理器”。负责理解指令、进行推理、生成规划。

• 代表： GPT-4o, Claude 3.5 Sonnet, Llama 3.1。
• 关键能力： Function Calling (工具调用)、长上下文理解。

2.3.2 记忆系统：向量数据库 (Vector Databases)

为了突破 LLM 上下文窗口的限制，我们需要外部记忆。

• 原理： 将文本转换为 Embedding（向量）存储起来，查询时通过相似度搜索找回相关记忆。
• 代表： Pinecone, Milvus, Chroma, FAISS (Facebook 开源)。

2.3.3 编排框架：Agent 开发工具

这是帮助你把“大脑”和“手脚”组装起来的脚手架。

• LangChain: 目前最流行的 LLM 应用开发框架，内置了丰富的 Agent 类型（ReAct, OpenAI Functions Agent）。
• AutoGPT/BabyAGI: 早期的全自动 Agent 探索者，侧重于任务的自动拆解和递归执行。
• CrewAI: 专注于多 Agent 协作，把 Agent 当作“员工”一样分工。

三、 核心内容/实战演练：构建一个 AI Agent (The Core - “How-To”)

好了，理论铺垫得差不多了。现在我们要进入最硬核的部分：Agent 的核心架构是如何工作的？ 我们将深入剖析每一个模块，并在最后亲手写一个 Python 项目。

3.1 Agent 的核心架构：三位一体

现代 LLM-based Agent 的架构虽然百花齐放，但万变不离其宗，基本都遵循 “思考-行动-观察” (Reasoning-Action-Observation) 的模式。其中，最经典的架构分解通常包含以下三个部分：

3.1.1 记忆模块 (Memory)

人类的记忆分为瞬时记忆、短期记忆和长期记忆。Agent 也一样。

1. 短期记忆 (Short-term Memory / Working Memory):

   • 定义： 对应 LLM 的 Context Window（上下文）。
   • 作用： 存储当前对话或任务的即时信息。
   • 局限： 容量有限（GPT-4o 是 128K tokens）。

2. 长期记忆 (Long-term Memory):

   • 定义： 外部存储，通常是向量数据库。
   • 机制： 当需要回忆“过去发生了什么”或“某份特定的知识”时，通过 RAG (Retrieval-Augmented Generation) 技术检索。
   • 核心数学概念：相似度计算
     假设我们有两个向量 $\vec{a}$ 和 $\vec{b}$，它们的余弦相似度计算公式为：
     $$\text{similarity}=\cos (\theta )=\frac{\vec{a}\cdot \vec{b}}{\Vert \vec{a}\Vert \Vert \vec{b}\Vert }$$
     其中 $\vec{a}\cdot \vec{b}$ 是点积，$\Vert \vec{a}\Vert$ 是向量的范数。值越接近 1，表示语义越相关。

3.1.2 规划模块 (Planning)

人类不会想到什么就立刻做什么，我们会列“待办清单”。Agent 也需要规划。

1. 任务分解 (Task Decomposition):

   • 技术： Chain-of-Thought (CoT)，Tree-of-Thought (ToT)。
   • Prompt 示例： “你的目标是写一篇关于 AI Agent 的博客。请将这个任务分解为 3-5 个关键的子步骤。”

2. 反思与精炼 (Reflection & Refinement):

   • 概念： Agent 做完一件事后，自我审视结果好不好，如果不好，问题出在哪，下次怎么改进。
   • 这正是 AutoGPT 这类“全自动” Agent 试图实现的，但也是目前最难做好的部分（容易陷入死循环）。

3.1.3 工具使用模块 (Tool Use)

这是 Agent 从“虚拟世界”走向“现实世界”的手脚。LLM 本身是离线的，知识有截止日期，也不会算数（复杂数学），所以它需要调用工具。

• 核心技术： Function Calling / Tools API。
• 流程：
  1. 用户定义好工具的 JSON Schema（描述工具名字、功能、参数格式）。
  2. LLM“思考”：我现在需要用这个工具。
  3. LLM 生成一段特定格式的 JSON（包含要调用的函数名和参数）。
  4. 程序解析 JSON，真的去调用外部 API 或函数。
  5. 把执行结果（Observation）塞回给 LLM。

为了更直观地理解这三者的关系以及数据是如何流转的，请看下面这张架构图：

3.2 AI Agent 的核心算法范式：ReAct

目前业界使用最广泛的 Agent 推理范式是 ReAct（Reasoning + Acting），这是由 Google Research 在 2022 年提出的论文《ReAct: Synergizing Reasoning and Acting in Language Models》中定义的。

简单来说，ReAct 就是强迫 LLM 在每一次行动前，先把自己的“思考过程”说出来（写出来）。

3.2.1 ReAct 算法流程图

我们用 mermaid 来展示 ReAct 的典型循环：

3.2.2 ReAct Prompting 的一个经典例子

让我们看一个具体的文本交互案例（模拟）：

Question: 2023年苹果公司的CEO是谁？他出生于哪一年？

Thought 1: 我需要先确定2023年苹果公司的CEO是谁。虽然我记得好像是库克，但为了确保准确，特别是涉及到具体年份，我应该搜索一下。
Action 1: Search[Apple CEO 2023]
Observation 1: 2023年苹果公司的CEO是蒂姆·库克（Tim Cook）。他于2011年接替史蒂夫·乔布斯成为CEO。

Thought 2: 好的，确认了CEO是Tim Cook。现在我需要查找他的出生年份。
Action 2: Search[Tim Cook year of birth]
Observation 2: 蒂姆·库克（Timothy Donald Cook）出生于1960年11月1日。

Thought 3: 现在我有了所有信息。2023年苹果CEO是Tim Cook，他出生于1960年。
Final Answer: 2023年苹果公司的CEO是蒂姆·库克（Tim Cook），他出生于1960年。

你看，这像不像是一个人在边查资料边自言自语地解决问题？这就是 ReAct 的威力：它让不可解释的 LLM 黑盒，变成了一个透明的、可追踪的决策过程。

3.3 数学模型：马尔可夫决策过程 (MDP)

虽然 LLM-based Agent 看起来很“文科”（都是自然语言），但其底层的决策逻辑依然可以用经典的强化学习框架来描述。

一个 Agent 与环境的交互过程可以被形式化为一个 马尔可夫决策过程 (Markov Decision Process, MDP)，它是一个五元组 $(\mathcal{S},\mathcal{A},P,R,\gamma )$：

1. 状态空间 ($\mathcal{S}$): 所有可能的环境状态的集合。在 Agent 中，状态 $s_t$ 可以看作是当前的对话历史、记忆检索结果以及工具返回的 Observation 的拼接。
2. 动作空间 ($\mathcal{A}$): Agent 可以执行的所有动作的集合。例如：“搜索‘最新AI新闻’”、“调用 Python 解释器计算 1+1”、“直接回答用户”。
3. 状态转移概率 ($P$): $P(s_{t+1}|s_t,a_t)$，表示在状态 $s_t$ 下执行动作 $a_t$ 后，环境转移到状态 $s_{t+1}$ 的概率。
4. 奖励函数 ($R$): $R(s_t,a_t)$，表示在状态 $s_t$ 下执行动作 $a_t$ 后获得的即时奖励。在 LLM Agent 中，奖励通常是稀疏的（只有任务完成了才给奖励），或者由人类反馈（RLHF）来定义。
5. 折扣因子 ($\gamma$): $0\le \gamma \le 1$，表示未来奖励的现值因子。

Agent 的目标是找到一个最优策略 ${\pi }^{\ast }:\mathcal{S}\to \mathcal{A}$，来最大化期望累积奖励：
$${\pi }^{\ast }=\arg \underset{\pi }{\max }\mathbb{E}\left[\sum _{t=0}^{\infty }{\gamma }^{t}R(s_t,a_t)\right]$$

目前的大部分 Agent 还没有到用 RL 端到端训练的地步，主要还是靠 Prompt Engineering（提示工程）来让 LLM 模仿这个决策过程。但像 GPT-4o 这种模型，其内部很可能已经在预训练阶段融入了大量的决策类数据。

3.4 实战演练：从零构建一个“研究助手” Agent

光说不练假把式。现在，我们将使用 Python + LangChain + OpenAI API 来构建一个简单但功能完整的 Agent。

3.4.1 项目介绍

我们的目标是创建一个 “PaperResearcher”。它可以：

1. 接受一个研究主题（例如：“AI Agent 的最新进展”）。
2. 自动使用 SerpAPI (谷歌搜索工具) 查找相关信息。
3. 对搜索结果进行总结。

3.4.2 环境安装

首先，你需要安装必要的 Python 库。建议使用虚拟环境。

pip install langchain langchain-openai langchainhub python-dotenv

你需要去申请两个 API Key：

1. OpenAI API Key: https://platform.openai.com/
2. SerpAPI Key: https://serpapi.com/ (用于联网搜索)

在项目根目录创建一个 .env 文件：

OPENAI_API_KEY="你的OpenAI Key"
SERPAPI_API_KEY="你的SerpAPI Key"

3.4.3 系统核心实现源代码

创建一个 main.py 文件，填入以下代码。我会在代码中详细注释每一步在做什么。

import os
from dotenv import load_dotenv

# 1. 导入 LangChain 核心模块
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.tools import WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_community.tools import DuckDuckGoSearchRun

# 加载环境变量
load_dotenv()

def create_research_agent():
    """
    创建并配置研究 Agent
    """
    
    # ====== 步骤 1: 初始化 LLM (大脑) ======
    # 我们使用 GPT-4o 或者 gpt-3.5-turbo (便宜点)
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    
    # ====== 步骤 2: 定义 Tools (工具) ======
    # 工具 1: DuckDuckGo 搜索 (不需要 API Key，我们用这个替代 SerpAPI 演示)
    search = DuckDuckGoSearchRun()
    
    # 工具 2: Wikipedia 查询
    api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=500)
    wikipedia = WikipediaQueryRun(api_wrapper=api_wrapper)
    
    # 把工具封装成列表
    tools = [search, wikipedia]
    
    # ====== 步骤 3: 定义 Prompt (指令模板) ======
    # 这是 Agent 的 "灵魂"。我们告诉它是谁，它有什么工具，以及它应该如何思考。
    prompt = ChatPromptTemplate.from_messages([
        ("system", """你是一个世界顶级的研究助理。你可以使用工具来获取最新的信息。
        执行任务时，请遵循以下格式：
        1. Thought: 思考你需要做什么
        2. Action: 选择一个工具 (duckduckgo_search 或 Wikipedia) 并输入参数
        3. Observation: 记录工具的结果
        4. Repeat (重复上述步骤直到你有足够的信息)
        5. Final Answer: 给出最终的全面总结
        
        开始工作吧！"""),
        ("placeholder", "{chat_history}"), # 可选：用于多轮对话记忆
        ("human", "{input}"),
        ("placeholder", "{agent_scratchpad}"), # 这里最重要：用来存储 Thought/Action/Observation
    ])

    # ====== 步骤 4: 构建 Agent ======
    # 使用 LangChain 内置的 'create_tool_calling_agent' 工厂函数
    # 它会自动处理 Function Calling 的逻辑
    agent = create_tool_calling_agent(llm, tools, prompt)
    
    # ====== 步骤 5: 执行器 (Executor) ======
    # AgentExecutor 负责运行 Agent 循环，处理错误，限制迭代次数
    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, max_iterations=3)
    
    return agent_executor

if __name__ == "__main__":
    print("欢迎使用 AI 研究助手！")
    agent = create_research_agent()
    
    while True:
        user_input = input("\n请输入你想研究的主题 (输入 'quit' 退出): ")
        if user_input.lower() == 'quit':
            break
            
        # 运行 Agent
        result = agent.invoke({"input": user_input})
        
        print("\n" + "="*50)
        print("最终报告:")
        print(result['output'])

3.4.4 代码解析与边界与外延

让我们解释一下上面代码中的几个关键点，也就是 “边界与外延”：

1. Agent vs AgentExecutor:

   • Agent: 只是一个生成“下一步做什么”的逻辑链（Runnable）。
   • AgentExecutor: 这是真正的 while 循环。它接收 Agent 的决定，去调用 Tool，把 Observation 塞回去，直到 Agent 说 “Finish” 或者达到 max_iterations（防止死循环）。

2. 代理的幻觉 (Hallucination):

   • 边界： 即使有了工具，LLM 依然可能会“编造假想的工具”或者在没有足够信息的情况下胡说八道。
   • 解决方案： 在 Prompt 里强调“如果你不确定，就继续搜索”，并且设置较低的 temperature。

3. 交互关系图 (Mermaid ER图)
   为了看清代码里各个组件是如何交互的，我们可以看下面这张实体关系图：

四、 进阶探讨/最佳实践 (Advanced Topics / Best Practices)

你已经跑通了第一个 Agent。现在，让我们看看在生产环境中构建 Agent 会遇到哪些挑战，以及该如何应对。

4.1 常见陷阱与避坑指南

4.1.1 陷阱一：无限循环 (Infinite Looping)

问题描述： Agent 陷入了“搜索 -> 不满意 -> 再搜索同样的内容”的死循环。
原因：

1. 工具返回的结果质量不高。
2. LLM 缺乏“反思”能力，不知道改变搜索关键词。
3. Prompt 没有给 Agent 设定明确的“停止标准”。
   解决方案：

• 硬限制： 设置 max_iterations（如我们代码里的 3 次）。
• 时间限制： 设置 max_execution_time。
• 更好的反思 Prompt： “如果你连续两次得到相似的结果，请尝试完全不同的搜索词，或者基于现有信息尝试给出结论。”

4.1.2 陷阱二：工具选择困难 (Tool Selection Paralysis)

问题描述： 当你给 Agent 10 个工具时，它可能会变得很笨，要么频繁调用错工具，要么不知道该用哪个。
解决方案：

• 工具精简： 一次只给 Agent 完成当前任务所必需的最少工具。
• RAG for Tools: 如果你有几百个工具，可以先用一个小的 LLM 或向量检索，先筛选出 Top 5 最相关的工具，再塞给主 Agent。
• 结构化工具描述： 确保每个 Tool 的 Description 写得极其清晰，让 LLM 一眼就知道什么时候用它。

4.1.3 陷阱三：上下文丢失 (Context Lost)

问题描述： 任务进行到第 5 步时，Agent 忘记了第 1 步用户说的原始要求是什么。
解决方案：

• 核心目标置顶： 在每一轮的 Prompt 开头，都把 User 的原始 Goal 重新拼进去。
• 记忆总结： 不要把所有历史对话都塞进去，而是每隔几步让 LLM 把前面的对话总结成一个 CoreMemory。

4.2 性能优化/成本考量

LLM 的调用是按 Token 收费的。一个复杂的 Agent 循环跑下来，可能比直接问 LLM 贵几十倍。

4.2.1 成本优化策略

1. 大小模型搭配（Mixture of Agents）:
   • 不要什么事都让 GPT-4o 干。
   • 路由策略： 简单的分类/总结工作用便宜的模型（Llama 3 或 GPT-3.5），只有复杂的推理规划才用贵的模型。
2. 缓存 (Caching):
   • 如果是相同的查询，直接从缓存里拿结果，不要重新跑 Agent。
   • 甚至可以缓存中间某一步的 Tool 调用结果。

4.3 多 Agent 协作 (Multi-Agent Systems)

一个 Agent 再强，也是单线程的。人类社会是通过分工协作来提高效率的，AI 也是如此。这是目前最火的方向之一。

4.3.1 概念架构：模拟公司组织架构

你可以创建不同角色的 Agent：

• CEO Agent: 负责拆解任务，分配工作。
• Researcher Agent: 负责上网搜索，查资料。
• Coder Agent: 负责写代码。
• Reviewer Agent: 负责检查代码或文案的错误。
• Integrator Agent: 负责把大家的工作拼起来，交付最终结果。

我们可以用一个 mermaid 图来展示这种协作：

4.4 最佳实践总结 (Tips)

1. 从简单开始 (Start Small): 不要一开始就想做“通用人工智能”。先做一个只能处理特定场景（比如“帮我生成 SQL”）的 Agent，把它打磨到极致。
2. Prompt 是灵魂: 花 80% 的时间调 Prompt。清晰的指令 >> 更贵的模型。
3. Human-in-the-Loop (人在回路中): 在关键节点（比如 Agent 准备调用支付接口、删除文件之前），加一个人工确认步骤。安全永远是第一位的。
4. 完善的日志 (Observability): Agent 的行为很难预测。你需要把每一次 Thought、Action、Observation 都记下来（比如用 LangSmith），以便出了 Bug 可以复盘。

五、 结论 (Conclusion)

5.1 核心要点回顾 (The Summary)

在这篇万字长文中，我们一起拆解了 AI Agent 的神秘面纱：

1. 是什么： AI Agent 是一个由 LLM 驱动的、具备感知、决策、行动能力的自主系统。它区别于传统程序的关键在于自主性和动态反馈。
2. 为什么： 为了让 AI 不再只是一个“问答机”，而是一个能帮我们处理复杂、多步骤任务的“真助理”。
3. 怎么做： 核心架构是 Memory (记忆) + Planning (规划) + Tools (工具)。通过 ReAct 范式将它们串联成一个循环。
4. 实践： 我们用 LangChain 搭建了一个能联网搜索的研究助手，亲眼目睹了 Thought -> Action -> Observation 的全过程。

5.2 行业发展与未来趋势

AI Agent 的概念其实并不新，甚至可以追溯到几十年前的符号主义 AI。但只有在今天，在 LLMs 强大的推理能力加持下，它才真正焕发了生机。我们可以用一个表格来简要回顾这段历史：

下一个十年：Agent 2.0 会是什么样？

• 具身智能 (Embodied AI): Agent 不再只存在于电脑里，而是拥有机器人身体，能在物理世界移动、操作物体。
• 个性化 (Personalization): 每个人都有一个专属 Agent，它完全了解你的生活习惯、工作偏好，就像你的数字分身。
• 经济闭环 (Economic Agents): Agent 能自主挣钱、消费、甚至与其他 Agent 进行交易，形成一个 AI 经济体。

5.3 行动号召 (Call to Action)

“纸上得来终觉浅，绝知此事要躬行。”

如果你是一名开发者，我强烈建议你现在就打开电脑，按照第三章的代码，自己动手跑一遍那个 Agent。当你看到 Terminal 里打印出 Thought: 我需要搜索... 时，你对“智能”的理解可能会发生一点微妙的变化。

如果你是一名产品经理或创业者，现在正是思考“Agent 如何改变我的行业”的最佳时机。在一个充满“工具”的世界里，第一个做出真正“懂你”的 Agent 的人，可能会定义下一个时代。

进一步学习资源：

1. 论文： 《ReAct: Synergizing Reasoning and Acting in Language Models》 (必读)
2. 论文： 《Sparks of Artificial General Intelligence: Early experiments with GPT-4》 (微软的 GPT-4 评测报告，里面有大量 Agent 类实验)
3. 框架： LangChain 官方文档 (https://python.langchain.com/)
4. 多智能体： CrewAI 文档 (https://docs.crewai.com/)

感谢你阅读到最后！关于 AI Agent，你有什么疯狂的想法吗？欢迎在评论区留言，我们一起讨论。