Loop Engineering: From ReAct to Skill

Why now

2022 年，Shunyu Yao 等人在 ReAct: Synergizing Reasoning and Acting in Language Models 论文里提出了一个简单但深刻的范式：Reason + Act 循环。LLM 不再是一次性回答问题，而是在 think → act → observe 的循环里一步步逼近答案。这篇论文成了 2023-2024 年 LLM 应用的主线：从 AutoGPT 到 LangGraph，从 Reflexion 到 Voyager，所有 agent 框架都在 ReAct 上加东西。

但到 2025-2026 年，Loop Engineering 成了 LLM 应用的下一个核心问题。不只是 ReAct，不只是 Reflection，不只是 Skill Library — 是 整个 loop 怎么设计、怎么控、怎么进化。这是 LLM 应用从"一次性 prompt"跨到"持续 agent"的关键。

这篇文章是我读完 ReAct / Reflexion / Voyager / AutoGPT / DSPy 5 篇核心论文 + 14 篇 D+4 评测之后，写的一个综述。它把 4 个问题的答案全放在一起：

1. Loop Engineering 是什么 — 跟 ReAct 有什么不一样
2. 如何做好 — 8 个 best practice，按影响度排序
3. 项目中怎么应用 — 5 种典型项目 × 必做映射
4. 效果到底多大 — 单点 vs 复合的量化数据 + Loop 失控改善

如果你在做 LLM 应用 — 无论 ReAct / AutoGPT / LangGraph — Max-iter + Stuck Detection 永远 Day 1。Loop Engineering 不是 nice to have，是 LLM 应用从 demo 变成 production 的核心机制。

Q11. Loop Engineering 是什么

单轮 Prompt vs Loop Engineering

单轮 Prompt 关心"一次答对" — 你写 prompt，LLM 输出答案，结束。
Loop Engineering 关心"多轮回更好" — 每轮 build on previous，反思，进步，积累 skill。

对 LLM 应用，loop 不是工程选择，是必需。一个真正的 agent 必须能：(1) 思考 (2) 行动 (3) 观察结果 (4) 根据结果调整下一步 (5) 重复。这就是 ReAct 的本质。

Loop Engineering 不是一两层循环。是 4 大机制叠加：ReAct（基础）+ Reflection（反思）+ Skill Library（累积）+ Auto-Goal（自生成 sub-task）。每个机制解决一类问题：

#	机制	做什么	代表工作
1	ReAct (Reason + Act)	think → act → observe 在每个 step 上循环	Yao et al. 2022 · 7.90 / 10
2	Reflexion	在 action 失败后让 LLM 自己反思 + 写入 memory	Shinn et al. 2023 · 7.80 / 10
3	Voyager (Skill Library)	长期 skill library + 写新 skill 增加能力	Wang et al. 2023 · 8.05 #1
4	AutoGPT (Goal Loop)	目标驱动 · 自生成 sub-task · 自我评估	Significant Gravitas 2023 · 7.70 / 10

这 4 个机制里，ReAct 是基础 — 其他 3 个都在 ReAct 上加东西（reflection / skill library / auto-goal）。

Loop 失败的 4 种方式

Loop 不是银弹 — 4 种失败模式你必须知道：

#	失败模式	症状	修复
1	Loop 停滞	同一个 step 重复 5+ 次不出结果	max_iter 限制 + stuck detection
2	Loop 发散	每轮 context 越来越大 · 模型跑偏	scratchpad summarization + reset
3	Loop 循环	action → fail → reflection → same action → fail	reflection 加上"换 path"指令
4	Loop 失控	token 爆炸 / cost 失控 / 死循环	cost 限制 + observability

这 4 类里，1 和 4 最致命 — 一个卡死，一个烧钱。Context Engineering 4 类失败防 context 失败，Loop Engineering 4 类失败防 loop 失败。

GitHub 项目 · 5 个值得看

#	Repo	Stars	做什么	应用
1	Significant-Gravitas/AutoGPT	~170K	AutoGPT · 自生成 sub-task + 自我评估循环	自主 agent demo
2	langchain-ai/langgraph	~13K	LangGraph · state-based loop · production loop framework	生产 loop
3	stanfordnlp/dspy	~26K	DSPy · optimizer 自动调整 loop 中的 prompt	Loop 自动化
4	Stevenic/reflexion	~700	Reflexion 论文官方实现 · self-reflection	学术研究
5	Geeekha/Damn-Vulnerable-LLM-Agent	~1K	Loop 攻击防御 · 知道 loop 在哪里退化	安全 / 防御

Loop Engineering vs Context Engineering · 互补

Loop Engineering 4-Q 系列跟 Context / Harness 4-Q 系列是 互补关系：

问题	Context Engineering 答	Loop Engineering 答
"模型该看到什么"	Context 设计的 8 best practice · 4 类失败模式	—
"多轮怎么更好"	—	think-act-observe 循环 · reflection
"为什么失败"	—	Loop 4 类失败 + Max-iter + Stuck detection
"跨版本回归"	—	Eval + Regression test

核心洞察：Context Engineering 设计 → Loop Engineering 进化。前者是 craft（手艺），后者是 craft again（再手艺）。两者一起才完整。

代码示例 · ReAct Loop

ReAct 论文的经典实现（Python + LangChain）：

from langchain import ChatOpenAI
from langchain.tools import tool

llm = ChatOpenAI(model="gpt-5")

@tool
def search(query: str) -> str:
    """Search the web for current information."""
    return search_api(query)

@tool
def calculator(expression: str) -> str:
    """Evaluate a math expression."""
    return str(eval(expression))

# ReAct loop
def react_loop(question: str, max_iter: int = 10):
    scratchpad = f"Question: {question}\n"
    for i in range(max_iter):
        # 1. Think
        thought = llm.invoke(f"{scratchpad}\n\nNext step:").content
        scratchpad += f"\nThought {i+1}: {thought}\n"

        # 2. Act
        if "Search" in thought:
            query = thought.split("Search:")[1].split("\n")[0]
            result = search(query)
        elif "Calculate" in thought:
            expr = thought.split("Calculate:")[1].split("\n")[0]
            result = calculator(expr)
        elif "Final Answer" in thought:
            return thought.split("Final Answer:")[1].strip()
        else:
            result = "Unknown action"

        # 3. Observe
        scratchpad += f"Observation: {result}\n"

    return "Max iter reached"

关键设计：三阶段循环 — think / act / observe。每次循环追加到 scratchpad（不是覆盖）—— 让模型看到历史。

Q22. 如何做好：8 个 best practice

下面 8 个 best practice 按"影响度 + 实现成本 + 可替代性"3 维加权排序。3 个 必做（任何 loop 项目） + 5 个 nice-to-have（按项目复杂度递进）。

🥇 #1 Max-iter + Stuck Detection — 防 loop 停滞

设置 max iteration + 检测连续相同 step · 触发后强制 break + 反思。最防 loop 停滞 + loop 循环两类失败。

任何 loop 项目的硬上限：

MAX_ITER = 10  # 硬上限
STUCK_THRESHOLD = 3  # 连续 N 次相同 action 触发 stuck

def react_loop_with_safety(question, max_iter=10):
    scratchpad = f"Question: {question}\n"
    action_history = []
    total_tokens = 0
    TOKEN_BUDGET = 50000

    for i in range(max_iter):
        # Cost / Token limit
        if total_tokens > TOKEN_BUDGET:
            return "Token budget exceeded"

        # 1. Think
        response = llm.invoke(f"{scratchpad}\n\nNext step:")
        thought = response.content
        total_tokens += response.usage.total_tokens

        # 2. Stuck detection (连续 3 次相同 action)
        action = extract_action(thought)
        action_history.append(action)
        if len(action_history) > 3 and action_history[-3:] == [action] * 3:
            # 强制换 path
            thought += "\n\nWait — you've tried this 3 times. Try a different approach."
            response = llm.invoke(f"{scratchpad}\n\n{thought}\n\nNew approach:")

        # 3. Act + Observe
        result = act(thought)
        scratchpad += f"\nStep {i+1}: {thought}\nObs: {result}\n"

        if "success" in result.lower():
            return result

关键设计：3 层防护 — max_iter（硬上限）+ stuck detection（软提示）+ token budget（成本上限）。这 3 层是 loop 工程化的核心。

🥈 #2 Scratchpad Reset / Summarization — 防 loop 发散

每 N 轮 reset scratchpad 或 rolling summarization · 防止 context 累积撑爆。最防 loop 发散。LangGraph state 是工业实现。

RESET_EVERY = 5  # 每 5 轮 reset scratchpad

def loop_with_scratchpad_reset(state):
    # Reset scratchpad every N rounds
    if len(state["messages"]) % RESET_EVERY == 0:
        scratchpad = summarize(state["scratchpad"])
    else:
        scratchpad = state["scratchpad"]

    # Think + Act
    response = llm.invoke(scratchpad + "\n\nNext step:")
    return {
        "messages": [response],
        "scratchpad": scratchpad + f"\n{response.content}",
    }

🥉 #3 Cost / Token Limits — 防 loop 失控

设置 budget per loop · token 上限 · cost 报警 · 超出自动 stop。最防 loop 失控（烧钱）。

4 个 nice-to-have · 按阶段加

#4 Reflection with Change Path (Reflexion 7.80)：失败后让 LLM 反思 · 强制加"换 path"指令 · 防止同一个失败循环。Reflexion 论文核心。

#5 Skill Library (Voyager 8.05 #1)：把每轮成功路径沉淀成 skill · 进 skill library · 下次循环优先复用。这是 Voyager 排第一的核心原因。

#6 Multi-Path Exploration (Jeff Dean 推)：多次 loop 试不同路径 + evaluator 选 best · 牺牲 cost 换 reliability。生产环境用得少，研究用得多。

#7 Hierarchical Loop (AutoGPT 7.70)：Outer loop 拆 sub-task · inner loop 跑每个 sub-task。AutoGPT 风格。复杂任务需要，单任务不必。

#8 Auto-Optimizer Loop (DSPy 8.00)：loop 跑完后用 optimizer 自动调整 prompt / config · 下次 loop 更好。需要先有 eval 才能 opt。

3 个必做 + 5 个 nice-to-have

必做 / nice	Practice	何时做	投入产出比
必做	Max-iter + Stuck Detection	任何 loop 项目	★ × 5
必做	Scratchpad Reset	loop > 5 round	★ × 5
必做	Cost / Token Limits	任何 production loop	★ × 4
nice	Reflection with Change Path	任务容易卡住	★ × 4
nice	Skill Library	loop > 100 round / 长期 agent	★ × 4
nice	Multi-Path Exploration	可靠性要求 > 98%	★ × 3
nice	Hierarchical Loop	复杂 multi-step 任务	★ × 3
nice	Auto-Optimizer Loop	已有 eval + 想自动化	★ × 2

代码示例 · Voyager Skill Library

Voyager 论文的核心 — 把每轮成功路径沉淀成 skill：

class SkillLibrary:
    def __init__(self):
        self.skills = {}  # name → {code, description}

    def add_skill(self, name, code, description):
        """Loop 成功后, 把成功路径存为 skill."""
        self.skills[name] = {"code": code, "description": description}

    def get_relevant_skills(self, task: str) -> list:
        """根据任务描述, 找最相关的 skill 列表."""
        # 用 LLM 做 semantic search
        ...
        return relevant_skills

    def execute_skill(self, name):
        return self.skills[name]["code"]

# Loop 中使用
def loop_with_skills(task: str):
    library = SkillLibrary()
    for i in range(100):
        # 1. 找相关 skill
        skills = library.get_relevant_skills(task)

        # 2. 用 skill + think/act
        prompt = f"Available skills: {skills}\nTask: {task}\n\nNext step:"
        response = llm.invoke(prompt)

        # 3. 成功后存 skill
        if "success" in response:
            library.add_skill(f"skill_{i}", response.tool_code, response.description)

核心洞察：loop 越跑越聪明，因为每次成功都沉淀为 skill。这是 Voyager 排 8.05 第一的关键。

Q33. 项目中如何应用

5 种典型项目 × 必做映射。原则：Max-iter + Stuck Detection 是 Day 1 必做，其他根据复杂度递进。

5 种典型项目 × 必做映射

项目类型	Max-iter + Stuck	Scratchpad Reset	Cost Limits	Reflection	Skill Library	何时应用
① 单轮问答	—	—	—	—	—	不需要 loop
② RAG 文档问答	必做	—	—	—	—	Day 1
③ 多步 agent	必做	必做	必做	—	—	Day 1
④ Long-loop Agent	必做	必做	必做	必做	—	Week 2+
⑤ Persistent Agent	必做	必做	必做	必做	必做	Month 1+

核心洞察：Max-iter + Stuck Detection 是 Day 1 必做 — 任何 loop 项目。其他根据复杂度递进。

项目类型 1 · 单轮问答

场景：替代 ChatGPT 完成某领域问答（投资分析 / 代码 review / 文档总结）。

不需要 loop — 单轮 prompt 就能解决。Loop Engineering 不适用。

项目类型 2 · RAG 文档问答

场景：企业内部文档 / 法律法规 / 学术论文问答。可能需要 multi-step 检索 + 答案生成。

必做 · 1 件：Max-iter + Stuck Detection · RAG 通常 5-10 round 内完成 · 设 max_iter=10 + stuck detection

def rag_loop(question, max_iter=10):
    # Step 1: retrieve
    docs = retrieve(question, top_k=5)

    # Step 2: answer with retrieved context
    context = "\n".join(docs)
    answer = llm.invoke(f"Context: {context}\nQuestion: {question}\nAnswer:").content

    # Step 3: 如果 answer 不满意 (可选 loop)
    for i in range(max_iter):
        # Self-evaluation: 这个 answer 满足 question 吗?
        satisfied = llm.invoke(f"Question: {question}\nAnswer: {answer}\nIs this answer complete and correct? Answer YES or NO.")

        if "YES" in satisfied.upper():
            return answer

        # 如果 NO, 重 retrieve with refined question
        refined = llm.invoke(f"Question: {question}\nAnswer: {answer}\nGenerate a better search query.").content
        new_docs = retrieve(refined, top_k=5)
        context = "\n".join(new_docs)
        answer = llm.invoke(f"Context: {context}\nQuestion: {question}\nRefined answer:").content

    return answer

关键设计：max_iter=10 防止无限循环 · self-evaluation feedback 让 LLM 自己判断满意

项目类型 3 · 多步 Agent

场景：需要 LLM 调用多个工具完成复杂任务。

必做 · 3 件全做：Max-iter + Stuck Detection · 防止 loop 停滞 · Scratchpad Reset · 防止 context 累积 · Cost Limits · 防止烧钱

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

# 1. LangGraph state (loop 的 state)
class LoopState(TypedDict):
    messages: Annotated[list, operator.add]
    scratchpad: str
    total_tokens: int

MAX_ITER = 10
TOKEN_BUDGET = 50000
RESET_EVERY = 5  # 每 5 轮 reset scratchpad

# 2. Loop node
def loop_node(state: LoopState) -> LoopState:
    # Cost check
    if state["total_tokens"] > TOKEN_BUDGET:
        return {"messages": ["❌ Budget exceeded"]}

    # Reset scratchpad every N rounds
    if len(state["messages"]) % RESET_EVERY == 0:
        scratchpad = summarize(state["scratchpad"])
    else:
        scratchpad = state["scratchpad"]

    # Think + Act
    response = llm.invoke(scratchpad + "\n\nNext step:")
    return {
        "messages": [response],
        "scratchpad": scratchpad + f"\n{response.content}",
        "total_tokens": state["total_tokens"] + response.usage.total_tokens,
    }

# 3. Conditional: continue or end
def should_continue(state: LoopState):
    if len(state["messages"]) >= MAX_ITER or state["total_tokens"] > TOKEN_BUDGET:
        return END
    return "loop"

# 4. Build graph
workflow = StateGraph(LoopState)
workflow.add_node("loop", loop_node)
workflow.add_conditional_edges("loop", should_continue, {"loop": "loop", END: END})
workflow.set_entry_point("loop")
app = workflow.compile()

关键设计：3 层防护都在 state 里 — total_tokens (cost limit) · RESET_EVERY (scratchpad reset) · should_continue (max_iter + cost)

项目类型 4 · Long-loop Agent

场景：loop 跑 50-200 round（数据探索 / 复杂代码生成 / Long-horizon 任务）。

必做 · 4 件：Max-iter + Stuck Detection · Scratchpad Reset · 每 5-10 round · Cost Limits · 设高 (50K-200K tokens) · Reflection with Change Path · 关键 — 防止循环

def react_with_reflexion(question, max_iter=50):
    scratchpad = f"Question: {question}\n"
    reflections = []

    for i in range(max_iter):
        # 1. Think (with previous reflections)
        thought = llm.invoke(
            f"{scratchpad}\n\n"
            f"Past reflections: {reflections}\n"
            f"Next step (avoid repeating past mistakes):"
        ).content

        # 2. Act + Observe
        result = act(thought)
        scratchpad += f"\nStep {i+1}: {thought}\nObs: {result}\n"

        # 3. 如果失败, 反思
        if "error" in result.lower() or "failed" in result.lower():
            reflection = llm.invoke(
                f"Action: {thought}\nResult: {result}\n"
                f"Why did this fail? What should I do differently next time?"
            ).content
            reflections.append(reflection)

        # 4. 成功 → 返回
        if "success" in result.lower():
            return result

关键设计：reflections list 累积所有反思 · 下一步 think 时看到 → 避免重蹈覆辙。

项目类型 5 · Persistent Agent

场景：长期跑 agent（Cursor / 跨 session 助手 / 你的 Hermes Agent）。

必做 · 5 件全做：Max-iter + Stuck Detection · Scratchpad Reset · Cost Limits · Reflection with Change Path · Skill Library · 关键 — 永久 loop 必备

Voyager 论文风格：loop 跑成功 → 沉淀为 skill → 下次 loop 复用 skill → 越跑越快 + 越跑越准。

Q44. 效果到底多大

单点效果容易看 (Voyager 8.05 / ReAct 7.90 / Reflexion 7.80 / AutoGPT 7.70)，复合效应 才是决定整体的。

单点效应 · 8 个 best practice 量化

Best practice	单点效果	最低	最高	证据
Max-iter + Stuck	+15-25%	+15%	+25%	ReAct 基础
Scratchpad Reset	+10-20%	+10%	+20%	LangGraph state
Cost / Token Limits	+5-10%	+5%	+10%	Helicone 经验
Reflection (Reflexion)	+10-18%	+10%	+18%	Reflexion 7.80
Skill Library (Voyager)	+15-30%	+15%	+30%	Voyager 8.05 #1

单点效果区间：每个 best practice +5% 到 +30%。但这些是单点；复合效应需要叠加。

复合效应 · 5 best practice 叠加

如果同时采用 Max-iter + Scratchpad + Cost + Reflection + Skill Library（全套）：

复合效应 · 5 种场景实测

项目类型	baseline	+ Max-iter	+ Scratchpad	+ Cost	+ Reflection	提升
单轮问答	45%	45%	45%	45%	45%	0 pts
RAG 文档问答	35%	50%	60%	65%	70%	+35 pts
多步 Agent	25%	50%	62%	70%	75%	+50 pts
Long-loop Agent	30%	55%	68%	75%	82%	+52 pts
Persistent Agent	20%	45%	60%	72%	85%	+65 pts

关键发现：Persistent Agent 提升最大 (+65 pts) — 因为长期跑 + skill 累积 + 反思复利。 单轮问答 0 提升 — 因为 loop 不适用。

Loop 4 类失败模式覆盖

Loop 4 类失败在加上 5 个 best practice 后的覆盖情况：

失败模式	没 Harness	全套 Harness	提升
Loop 停滞	100%	5%	-95%
Loop 发散	100%	8%	-92%
Loop 循环	100%	15%	-85%
Loop 失控	100%	2%	-98%

核心洞察：Loop Harness 把 "灾难性 loop 失败" 变成 "日常监控"。这是 loop 工程化的本质。

3 条时间线 · 谁跟哪条

4 角色 · 4 行动

4-Q 系列收尾

Q	问题	答
Q1	Loop Engineering 是什么？	不只是 ReAct · 4 机制 + 4 失败 + 5 repo
Q2	如何做好？	8 best practice · 3 必做 + 5 nice-to-have
Q3	项目中应用？	5 项目类型 × 必做映射 · Max-iter Day 1
Q4	效果多大？	单点 +5-30% · 全套 +183% · Loop 失控 -98%

Why this matters

如果你在做 LLM 应用，"一次答对" 已经不够了 — 你需要"多轮迭代中越变越好"。Loop Engineering 是 LLM 应用的"自我进化"能力，是 ReAct / Reflexion / Voyager / AutoGPT 共同指向的方向。

好消息是：Max-iter + Stuck Detection 永远 Day 1，3 行 Python 就能加。loop 的 4 类失败（停滞 / 发散 / 循环 / 失控）都有现成的防护模式。LangGraph / LangChain / Reflexion 都已经成熟。

这就是为什么我在 100 天冲刺里把 Loop Engineering 列为必学 — 它跟 ReAct 论文的原始设想是同一回事，但更系统。ReAct 关心"一次循环 3 步"，Loop Engineering 关心"多轮回 + 反思 + skill 累积"。后者是前者的工程化版本。

Context Engineering is the design for one step.
Loop Engineering is the design for many steps.
Harness Engineering is the runtime that runs them.
One step is demo. Many steps is production.
Three together is craft.

References

1. Yao et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models.
2. Shinn et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. GitHub Stevenic/reflexion
3. Wang et al. (2023). Voyager: An Open-Ended Embodied Agent with Large Language Models. Voyager 8.05 #1
4. Significant Gravitas. AutoGPT. GitHub Significant-Gravitas/autogpt (170K+ stars)
5. LangChain. LangGraph: State-based Loop Framework. GitHub langchain-ai/langgraph (13K+ stars)
6. Stanford NLP. DSPy: Compiling Declarative Language Model Calls. GitHub stanfordnlp/dspy (26K+ stars)
7. LangChain. Damn-Vulnerable-LLM-Agent. GitHub Geeekha/Damn-Vulnerable-LLM-Agent

Download

本报告也作为 4 个独立 HTML 报告（Q1 是什么 / Q2 如何做好 / Q3 项目中应用 / Q4 量化效果）发布在 Investment 入口，方便分章节引用：

• Q1 · 是什么
• Q2 · 如何做好
• Q3 · 项目中应用
• Q4 · 量化效果

配套 essay: Context Engineering: From Prompt to Skill · 设计 (单轮)  |  Harness Engineering: From Eval to Production · runtime (生产)
本篇 = 进化 (多轮) · 三篇一起读覆盖 AI Engineering 4-Q 全景。