AI —— Agent相关概念-1

文章目录

概览
- [Agent 推理范式进化链路](#Agent 推理范式进化链路)
- CoT
- 设计模式
- - ReAct
  - [Plan and solve](#Plan and solve)
  - [REWOO（Reason without Observation）](#REWOO（Reason without Observation）)
  - LLMCompiler
  - Reflexion
  - [LATS（Language Agent Tree Search）](#LATS（Language Agent Tree Search）)
  - Self-discover
- 工程原子组件
- - Routing
  - [Tool Use vs RAG](#Tool Use vs RAG)
  - Skill
- 架构设计思想，上层架构范式
- - Multi-Agent
- [Agent 运行时底座](#Agent 运行时底座)
- - Harness
Agent
- 概念
- [Agent = Model + Harness。](#Agent = Model + Harness。)
[AI 工程三层体系AI 工程三层体系](#AI 工程三层体系AI 工程三层体系)
- [一、Prompt Engineering｜提示词工程（指令层：单次交互，输入话术）](#一、Prompt Engineering｜提示词工程（指令层：单次交互，输入话术）)
- [二、Context Engineering｜上下文工程（信息层：喂什么数据，窗口内容管控）](#二、Context Engineering｜上下文工程（信息层：喂什么数据，窗口内容管控）)
- [三、Harness Engineering｜驾驭 / 缰绳工程（系统层：Agent 运行底座，全生命周期管控）](#三、Harness Engineering｜驾驭 / 缰绳工程（系统层：Agent 运行底座，全生命周期管控）)
- 四、三层层级对比表
- 五、落地演进顺序

概览

Agent 推理范式进化链路

主线进化：纯内部推理 CoT → 接入外部工具 ReAct → 前置规划 Plan → 批量查数 ReWOO → DAG 并行调度 LLMCompiler → 自省纠错 Reflexion → 多路径择优 LATS → AI 自主解题 Self-Discover。

关键概念一句话区分

LLM：智能大脑，负责推理、决策、输出指令；
Agent Loop：思考 - 行动 - 反馈的循环运行规则；
Harness：身体 + 器官，Agent 运行底座，承载循环调度、工具管控、资源治理；
ReAct/Plan/ReWOO/LLMCompiler：Agent 的任务执行设计模式；
Reflexion/LATS/Self-Discover：优化思考、多选方案、自创方法的增强能力
Tool/RAG/Skill/Routing：Agent 对接外部资源的手脚与能力组件；

统一例题：算：(125+75)×8 − 360÷12。

CoT

（Chain-of-Thought，思维链）纯文本推理。纯模型内部推理，无任何外部工具，无环境交互，仅通过分步思维推导答案。。

原理

不调用计算器、不查外部数据，把思考步骤白纸黑字写出来，分步心算，全部在模型脑子里完成，只有思考、没有 Action、没有外部 Observation。
公式：Question → Step1→Step2→Step3→Answer

示例

复制代码

Q：(125+75)×8 − 360÷12
Thought1：先算括号 125+75=200
Thought2：200×8=1600
Thought3：再算除法 360÷12=30
Thought4：1600−30=1570
Answer：1570

短板

遇到大数、专业数据、实时信息只能靠模型记忆，容易幻觉算错，不能外接计算器 / 搜索。

定位：纯推理范式，无工具交互，所有后续 Agent 都是在 CoT 基础上加了「外部行动」。

设计模式

（推理范式 / 设计模式，Prompt 即可实现，不属于代码框架）

ReAct

Plan and solve

Reason without Observation（REWOO）

LLMCompiler

Reflexion

Language Agent Tree Search

Self-discover

ReAct

业界标准基础 Agent 模式，遵循Thought 思考 → Action 行动 → Observation 观测循环模式。

原理

思考下一步要干啥调用计算器工具工具返回结果，循环往复；算一步、调一次工具、拿到结果再想下一步。
CoT 只「动脑」；ReAct「动脑 + 动手查结果」。

示例

复制代码

Thought：先算括号125+75，需要计算器
Action：Calc[125+75]
Observation：200

Thought：用上一步结果×8
Action：Calc[200×8]
Observation：1600

Thought：单独计算360÷12
Action：Calc[360/12]
Observation：30

Thought：最后做减法1600-30
Action：Calc[1600-30]
Observation：1570
Final：1570

和 CoT 区别

CoT 全靠心算；ReAct 不会硬算，会借助计算器帮忙，分步串行调用工具。

Plan and solve

前置规划型设计模式，两段式架构：开局一次性拆解完整任务步骤，后续严格按清单顺序串行执行。

原理

两段式：
1. Plan：问题没动手前，一次性列出全部计算步骤清单；
2. Solve：严格按清单顺序逐个调用工具执行，中途不改计划。
ReAct 走一步定一步；Plan 开局定完整流程。

示例

复制代码

Plan（提前写全步骤）：
1. 计算A=125+75
2. 计算B=A×8
3. 计算C=360÷12
4. Result = B−C

Solve按顺序执行：
Calc[125+75]=200 → Calc[200×8]=1600 → Calc[360/12]=30 → Calc[1600-30]=1570

对比 ReAct

ReAct：算出 A 才想到算 B；Plan：还没计算就把 ABCD 全规划完毕。

REWOO（Reason without Observation）

解耦式规划设计模式（规划与观测分离的批量执行模式，Plan & Solve 改良模式），三段架构：Planner 占位拆解 → Worker 批量串行取值 → Reasoner 统一汇总。

一次性收集所有待查询参数，集中调用工具，大幅减少 LLM 思考轮次，工具执行仍为串行。

原理

三段架构：Planner → Worker → Reasoner
1. Planner：只写公式、用占位符，全程不调用任何工具；
2. Worker：一次性批量把所有占位参数全部调用工具算出；
  
  虽然是一次性把所有待算项全部收集完毕、统一送入工具层 （区别 Plan&Solve 算一个、拿到结果再写下一个式子），但工具还是排队、顺序挨个运算，前一个算完才启动下一个 ，只是减少了中间 LLM 思考轮次，工具调用依旧串行。
3. Reasoner：代入所有数据统一出结果。

示例

复制代码

Planner：
X = 125+75
Y = X*8
Z = 360/12
Ans = Y-Z
（X/Y/Z全是空占位，不计算）

Worker：一次性批量请求所有算式：Calc[125+75]、Calc[360/12]
Obs：X=200，Z=30

Reasoner：代入：Y=200*8=1600，Ans=1600-30=1570

和 Plan&Solve 区别

Plan：算一个、等一个结果、再算下一个；
ReWOO：所有需要查询的数据一次性批量调用工具，只集中拉取一轮外部结果，大幅减少 LLM 轮次。

LLMCompiler

DAG 并行规划设计模式（基于依赖 DAG 的任务并行调度模式，ReWOO 升级版模式），无依赖任务并行执行、有依赖任务阻塞等待。

原理

Planner 拆解任务，生成依赖 DAG ：互不依赖的计算任务可以并行同时调用工具；存在依赖的任务等前置结果就绪再执行。

示例

复制代码

DAG拆解：
任务①：A=125+75
任务②：B=360÷12
→①②无依赖，可以并行同时开两个计算器一起算；
任务③：Y=A×8（依赖①）
任务④：Ans=Y−B（依赖③、②）

调度：
并行执行Calc[125+75]、Calc[360÷12] → 同时拿到200、30；
再串行算200×8，最后做减法。

和 ReWOO 区别

ReWOO：批量但是顺序挨个算；
LLMCompiler：无关任务多线程并行同时算，速度最快。
大模型调用数量不变，只在【工具执行】一个串行、一个并行。

进化链小结：

CoT (纯心算)→ReAct (串行单步调工具)→Plan (先列清单串行执行)→ReWOO (清单 + 批量串行取值)→LLMCompiler (清单 + DAG 并行取值)

ReAct/PlanSolve/ReWOO/LLMCompiler 同属任务执行类 Agent 设计模式谱系，演进链路的四代设计模式。

Reflexion

反思迭代设计模式（自我批判 - 修正 - 记忆的闭环优化模式。事后复盘纠错，外挂增强层，不负责编排步骤）

原理

执行输出 → 自我批判Critique → 修改答案Revise + 经验入库

前面 5 种都是「怎么算题」，Reflexion 是「算完检查改错」，可以套在 CoT/ReAct/LLMCompiler 任意流程后面。

示例

第一轮用 ReAct 算错：(125+75)×8=1500，最终答案 1470

复制代码

Critique反思：200×8正确结果是1600，我乘法计算出错，中间步骤失误；
Revise修正：重新带入正确数值，算出1570；
Memory记录：200×8不要算成1500，后续同类计算留意。

定位区别

前面是解题执行模式 ；Reflexion 是改错优化插件。

LATS（Language Agent Tree Search）

树搜索择优设计模式（MCTS+ReAct+Reflexion 融合的多路径探索模式），单次问题生成多条解题分支，通过反思打分剪枝、择优输出，解决单一路径解题的局部最优问题。

原理

对同一个问题生成多条不同解题分支；
每条分支执行一小段后用 Reflexion 打分、淘汰劣质路线；
优质分支继续深挖，多条路径跑完选出最优答案。

示例

题目生成三条解题分支：

分支 1：严格按原式分步四则运算（标准解法）
分支 2：拆分变形：125×8+75×8−360÷12（乘法分配律）
分支 3：错误思路：先算 8−360，明显逻辑错误

用反思打分：分支 3 不合理直接剪枝；分支 1、2 分别计算，核对结果一致，确定答案。

区别

前面所有范式只走单一条解题路线；LATS 多路并行试错、择优。

Self-discover

自主推理范式（自主生成推理方案的通用解题模式），无预设模板约束，模型自主分析问题、生成专属解题逻辑与执行方案，是最高阶的通用推理范式。

原理

不给任何 CoT/ReAct/Plan/LLMCompiler 模板，模型自己分析问题，自主生成一套专属解题步骤，自己决定用什么逻辑、要不要调用工具。

示例

只丢式子(125+75)×8 − 360÷12，无任何范式提示：

AI 自主思考：

复制代码

这种四则运算，我先拆成两大部分，一部分括号乘式、一部分除法，分开查询数值再合并，我先列出要算的两个基础算式统一调用计算器......

AI 自发造出类似 LLMCompiler 的执行逻辑。

关键区别

CoT/ReAct/Plan... 全是人提前规定好规则，AI 按模板干活；
Self-Discover：只给问题，AI 自创解题范式。

小结：Reflexion/LATS（Language Agent Tree Search）/Self-discover三者是推理优化设计模式，用来增强基础 ReAct/Plan 类模式效果。

工程原子组件

不是框架、不是设计模式，是系统基建模块。

作为基础能力，被上面任意设计模式、上层框架调用

Routing

任务分发组件；输入分发、多 Agent / 多技能调度路由逻辑

Tool Use vs RAG

两类数据源接入组件

ToolUse：外部动态工具接入组件
RAG：私有知识库检索接入组件

Skill

工具封装组件；把零散 Tool 打包成可复用原子能力

架构设计思想，上层架构范式

系统架构范式（架构设计模式）

Multi-Agent

把单 Agent 能力拆分成多个角色 Agent 协作的架构思想，不是单一 Prompt 模式，也不是具体框架；

可基于 Harness 落地成多 Agent 系统，MetaGPT/AutoGen 都是该架构思想的落地产品。

Agent 运行时底座

（完整运行框架，底层容器框架）

Harness

完整运行框架（底层容器框架）

Agent 系统运行框架，承载组件注册、路由调度、Agent 生命周期、多实例管理、任务编排；

所有上面的设计模式（ReAct/Reflexion/LATS）、Multi-Agent 架构、Skill/Routing 组件，全部挂载在 Harness 框架里运行。

Agent

概念

Agent：以大模型作为决策大脑，遵循「感知→思考→行动→反馈」循环，能主动调用外部工具、和真实环境交互、自主分步完成复杂任务的智能体。

核心本质：突破 LLM 仅靠自身知识生成文本的局限，具备动手能力、环境反馈、闭环迭代。

Agent = 感知（Perception）+ 思考（Reason）+ 行动（Action）
工程化（AI 智能 Agent）拆分

Agent = LLM大脑 ⊕ Memory(记忆) ⊕ Tools(工具集) ⊕ Planning(任务规划) ⊕ Reflection(自省反馈)

三大必备要素（缺一个不算标准 Agent）

LLM 决策大脑：负责语义理解与任务决策

CoT 只有思考、不碰外部环境 → 不是 Agent；
闭环循环：感知→思考→行动→观测反馈迭代循环（Agent Loop）

固定循环是 Agent 的运行骨架；
外部行动能力：Tool/RAG/Skill 支撑环境交互

可以搜网页、算题、查数据库、调用 API，拿到真实世界数据。

Agent 最基础的 "感知→思考→行动→反馈" 循环，所有复杂模式的基础

感知 Observation：接收环境结果（工具返回数据、知识库检索内容、用户输入）；
思考 Thought/Reason：LLM 基于已有信息分析：缺什么信息、下一步做什么；
行动 Action：输出工具调用指令（搜数据、算算式、查 DB）；
反馈（新 Observation）：工具返回结果，并入上下文，回到感知，开启下一轮循环。

ReAct 模式的核心思想是将"推理"和"行动"分离

Reason（推理）与 Action（行动）拆分落地在原生循环里，即 ReAct = 把「内在思考显性化 + 工具行动拆分」，绑定到一轮一轮的 Agent Loop 中。
ReAct 拆分定义
- Thought（显性推理 Reason）：LLM 白纸黑字写出思考逻辑，不再藏在隐性 CoT 里；
- Action（落地行动）：根据思考输出确定的工具指令；
- Observation（外部观测）：环境真实返回，作为下一轮 Thought 输入。

Agent 与 Harness 角色定位

Agent：决策者（思考、规划、选工具）
Harness：执行者（落地运行、管控风险）
Agent 出方案，Harness 做落地；Harness 反馈成败，Agent 迭代方案，形成循环自修正智能链路。

Harness

Harness = Tools + Knowledge + Observation + Action Interfaces + Permissions

Agent = Model + Harness。

Agent (智能体)：

是指具备自主感知、思考与行动能力的AI实体。它由大语言模型（LLM）驱动，负责理解复杂任务、进行推理规划，并决定何时调用外部工具来达成目标。

Harness (驾驭层/工程框架)：

是围绕模型运行的一套控制系统和工程化手段。它不提供智能，但通过限制边界、规划任务、管理上下文、错误纠正和失败重试等机制，确保Agent能稳定、可靠地长时间运行。

Agent Harness = 包裹 LLM 的运行时基础设施，管理工具调度、上下文工程、安全执行、状态持久化和会话连续性。LLM 只负责推理决策。

模型本身只是一个推理引擎，它不能独立行动。真正让它变成 Agent 的，是包裹在它周围的五个 Harness 组件。

Tools（工具），模型的手脚。Read、Write、Edit、Bash、Grep......这些工具赋予模型与文件系统、终端、网络交互的能力。没有工具，模型只能说，不能做。

Tools｜手脚层：外部能力具象化
- 定位：Agent 和现实环境交互的执行终端，补齐 LLM 无法直接操作软硬件 / 系统的短板；
- 常见能力：文件读写 (Read/Write/Edit)、终端命令 (Bash)、检索 (Grep)、数据库查询、接口调用、代码运行等；
- 作用：将 LLM 输出的工具调用指令翻译成操作系统 / 第三方服务可执行的真实动作。
Context（上下文），模型的记忆加载器。CLAUDE.md、系统提示词、对话历史、工具定义------这些上下文在每一轮循环中被注入模型，决定了模型看到什么、知道什么。上下文管理的精妙之处是，它不仅是被动的信息传递，还包括主动的压缩和重注入策略。

Context｜短时视野层：单次轮次输入管控
- 承载内容：系统 Prompt、项目规则 (CLAUDE.md)、本轮对话历史、工具入参 / 返回结果、工具描述文档；
- 核心能力：上下文裁剪、信息压缩、增量注入，解决上下文窗口超限问题；
- 生命周期：单轮思考循环有效，一轮对话结束临时上下文可回收，不跨会话留存。
Memory（记忆），模型的长期存储。跨会话的记忆持久化，让模型能"记住"你的偏好、项目规则和历史决策。CLAUDE.md 是显式记忆，自动记忆（~/.claude/memory/）是隐式记忆。没有 Memory，每次对话都从零开始。

Memory｜长期记忆层：跨会话持久存储
- 分类：
  - 显式记忆：CLAUDE.md等配置文件，人工定义项目规范、约束、使用偏好；
  - 隐式记忆：自动落地持久化（如~/.claude/memory/目录），Agent 自主沉淀历史方案、过往错误、用户习惯；
- 作用：新会话启动时自动加载历史沉淀信息，避免每次对话从零初始化。
Hooks（钩子），模型的神经反射。事件驱动的自动化机制，在工具执行前后触发自定义逻辑。比如每次保存文件前自动格式化，每次提交前自动运行 lint。Hooks 让 Harness 有了"条件反射"的能力------不需要模型主动决策，某些行为会自动发生。

Hooks｜事件自动化层：前置 / 后置拦截逻辑
- 机制：事件驱动、脱离 LLM 决策自动执行，属于 Harness 内置回调逻辑；
- 典型场景：文件保存前自动格式化、代码提交前自动 Lint 校验、工具调用失败自动重试、入参前置校验；
- 价值：标准化流程，减少 LLM 重复思考琐碎规范动作，降低人为失误。
Permissions（权限）------模型的安全围栏。哪些工具可以自由使用，哪些需要人工审批，哪些完全禁止------权限系统是 Harness 的安全底线。它解决了一个核心矛盾：你希望 Agent 足够自主以提高效率，但又不希望它自主到失控。

Permissions｜安全围栏层：执行权限管控
- 分级策略：工具白名单（免审批直接执行）、人工审批权限（高危操作弹窗确认）、黑名单（彻底禁用）；
- 解决矛盾：平衡 Agent 自主性与安全风险，防止越权删改文件、执行高危系统命令、访问涉密资源。

Harness = 工具 + 上下文管理 + 执行环境 + 权限控制。

AI 工程三层体系AI 工程三层体系

Prompt / Context / Harness 三大 AI 工程分层（Agent 三层架构，从内到外）

Prompt = 告诉模型做什么；Context = 给模型看什么资料；Harness = 搭建整套系统让模型可靠跑完全流程

一、Prompt Engineering｜提示词工程（指令层：单次交互，输入话术）

1、定义

聚焦单轮 / 单次会话输入文本设计 ，通过优化指令措辞、角色、格式、样例，在上下文窗口内约束模型输出，只管控 "对模型说什么"。

2、核心工作

System Prompt 系统角色设定、用户指令优化
Few-shot/CoT 思维链、输出格式约束（JSON/Markdown）
话术精简、规避幻觉、提示注入防护

3、边界 & 短板

仅作用单次上下文窗口，会话结束指令失效；没法解决长任务、多轮记忆、外部数据缺失、工具调用问题。

4、落地示例

复制代码

你是SQL专家，根据表结构生成查询，只返回标准SQL，禁止额外解释
示例：入参xxx→SELECT ...

二、Context Engineering｜上下文工程（信息层：喂什么数据，窗口内容管控）

1、定义

Karpathy 提出：在有限上下文窗口中，动态筛选、组装、压缩精准信息，决定模型每一步能看见哪些数据，解决「给多超限、给少缺信息」，是 Prompt 的上层信息供给层。

类比：LLM=CPU，Context Window = 内存，上下文工程 = 内存调度管理器

2、四大核心动作（选 / 拼 / 压 / 存）

Select 选取：RAG 向量召回、BM25 检索、过滤无效脏数据，防上下文污染
Struct 结构：文档分块、结构化排版（JSON/MD）、区分【指令 / 知识库 / 工具结果】
Compress 压缩：超长文本摘要、去重、精简冗余，节省 Token
Sequence 排序：信息优先级排布（指令在前、参考资料居中、历史记录靠后）

3、落地场景

Text-to-SQL：动态拉取表结构 + 字段注释 + 历史报错，按需塞进上下文；长文档问答分片注入。

三、Harness Engineering｜驾驭 / 缰绳工程（系统层：Agent 运行底座，全生命周期管控）

1、起源 & 定义

Harness=Agent−LLM：除去大模型本身，所有配套运行环境、软件系统、执行规则统称 Harness，构建跨会话、长周期 Agent 稳定运行底座，解决 Prompt+Context 解决不了的工程稳定性问题。

Harness = 马具，LLM = 野马；靠缰绳约束 AI 不乱跑、不乱生成、安全执行。

2、Harness 五大组成模块（包含 Context 工程，Context 是 Harness 子集）

状态持久化：跨会话记忆、任务断点续跑、全局状态存储（脱离单次上下文窗口）
工具编排：函数调用、Shell/DB/SFTP 工具路由、Skill 调度、入参校验
校验闭环：结果自检、错误重试、人工审批卡点、自动纠错规则（犯错固化规则进系统，不反复改 Prompt）
观测运维：调用埋点、成本管控、Token 监控、异常熔断、降级策略
流程编排：LangGraph / 多 Agent 流水线、分步任务拆解、子任务分发聚合

3、核心思想

Agent 出错不反复微调 Prompt，而是把修复逻辑固化进 Harness 系统，从架构杜绝同类问题复现。

四、三层层级对比表

维度	Prompt Engineering	Context Engineering	Harness Engineering
管控层级	单次指令文本	上下文窗口信息	全 Agent 运行系统
核心问题	指令怎么写才看得懂	哪些数据进上下文	系统怎么稳跑长任务
生命周期	单轮对话有效	单步推理有效	跨会话、全任务周期
从属关系	上下文的指令片段	Harness 的信息子模块	顶层工程底座
典型产出	Prompt 模板库	RAG 检索链路、上下文组装引擎	Agent 运行框架、调度 + 校验系统

五、落地演进顺序

初代：只做 Prompt：小任务、单轮问答够用，复杂 Agent 必翻车
二代：叠加 Context：接入 RAG 动态喂数据，解决缺资料幻觉，但跨会话、工具调度仍不可控
三代：完整 Harness+Context+Prompt：生产级 Agent 标配（Text-to-SQL 智能代理、代码生成 Agent 主流架构）