循环工程：构建AI自我迭代的自动化工作流

循环工程AI提示词自动化工作流

于 2026-07-07 15:49:32 修改

·本内容遵循CC 4.0 BY-SA版权协议

这次我们来看一个关于“循环工程”的技术概念。如果你已经对AI提示词（Prompt）有了一定了解，但感觉效果总是不稳定，或者希望AI能更自主、持续地完成任务，那么这个思路值得你关注。它不是一个具体的软件或模型，而是一种让AI系统能够自我迭代、自我优化的工程化方法，核心是让AI在循环中评估、调整并执行，减少人工干预。

简单来说，循环工程就是为AI设计一套“工作流”，让它能自动检查自己的输出，发现问题，然后基于规则或另一个AI模型来优化输入（Prompt），再进行新一轮的生成，如此循环，直到达到预设的目标。这比单纯写一个静态的Prompt要强大得多，尤其适合内容批量生成、代码迭代、数据分析报告自动化等需要持续优化和质量控制的场景。

本文将重点拆解循环工程的核心思想、典型架构，并通过一个模拟的“AI内容质检与优化”案例，展示如何从零搭建一个简易的循环系统。我们会关注其可行性、关键组件（如评估器、优化器）、以及如何用常见的开发工具（如Python、LangChain框架思想）将其实现。虽然不涉及特定模型的显存占用，但会讨论其对计算资源的持续消耗模式以及如何设计退出机制以避免无限循环。

1. 核心能力速览

能力项	说明
核心理念	构建AI自我评估、优化、再执行的自动化闭环，替代单次静态Prompt调用。
核心组件	执行器（LLM）、评估器（规则/模型）、优化器（规则/LLM）、任务队列与状态管理。
硬件门槛	取决于所用AI模型。可使用云端API（如OpenAI GPT-4）降低本地负担，也可部署本地模型（需相应GPU资源）。
启动方式	无“一键启动”，本质是一套程序或脚本，通过命令行或任务调度器（如cron, Celery）触发。
接口能力	通常以REST API或消息队列形式提供任务提交和结果查询接口。
批量任务	核心优势。天然支持批量处理，通过队列管理循环任务，实现通宵自动化运行。
适合场景	内容生成与优化、代码调试与重构、数据清洗与分析报告、自动化测试与评估。

2. 适用场景与使用边界

循环工程并非万能，理解其适用边界是成功应用的第一步。

它最适合以下场景：

质量要求波动性任务：例如，生成营销文案，要求每次输出都必须包含特定关键词且语句通顺。单次Prompt可能偶尔遗漏，循环工程可以加入“关键词检查”和“通顺度评分”环节，不达标则自动重写。
多步骤决策与验证：例如，让AI根据需求编写一段代码，然后自动运行单元测试，如果测试失败，则分析错误日志并重新修改代码。
大规模批量处理：需要对成千上万条数据执行相似但需个性化调整的操作，如为每件商品生成独特的描述，并确保描述风格一致、无违规词。
持续优化与探索：例如，自动化A/B测试不同的广告文案Prompt，根据点击率模拟数据自动选择效果更好的方向进行下一轮生成。

需要谨慎使用或不适用的场景：

简单、确定性任务：如果任务只需一次准确的查询就能解决（如翻译一个句子），引入循环只会增加复杂度和成本。
缺乏明确评估标准：如果“好”与“坏”无法用规则或另一个相对可靠的AI模型来量化判断，循环将失去方向，可能陷入无效迭代。
实时性要求极高的场景：循环需要时间，每次迭代都涉及LLM调用、评估计算，不适合毫秒级响应的交互。
伦理与合规风险：在涉及事实核查、法律文书、医疗建议等领域，必须设立严格的人工审核节点，不能完全依赖自动化循环，避免错误传播或产生有害内容。

重要边界提醒：任何自动化内容生成系统，都必须内置版权、隐私和安全性审查。例如，在循环中应加入违禁词过滤、抄袭检测（与已有内容比对）等环节，确保输出内容合法合规。

3. 环境准备与前置条件

搭建一个循环工程系统，更像是一个软件开发项目，而非部署一个现成模型。以下是通用的环境与技能准备清单。

1. 开发环境：

操作系统：Windows 10/11, macOS, 或 Linux (推荐Ubuntu)。Linux系统在部署后台服务时通常更稳定。
编程语言：Python 3.8+ 是首选，因其在AI和自动化生态中有最丰富的库支持。
版本控制：Git，用于管理你的循环工作流代码。

2. 核心依赖库：

AI模型调用：
- 如果使用云端API（如OpenAI, Anthropic Claude, 国内大模型平台），需准备相应的API Key和官方SDK (openai, anthropic等)。
- 如果使用本地模型（如通过Ollama、vLLM、Transformers部署），需配置好相应的模型服务环境。
流程编排（可选但推荐）：LangChain、LlamaIndex等框架提供了构建链（Chain）和代理（Agent）的高级抽象，可以简化循环逻辑的搭建。本文示例将借鉴其思想，但不完全依赖。
任务队列与后台执行（用于“通宵运行”）：对于复杂或耗时的循环，推荐使用 Celery + Redis/RabbitMQ，或 Dramatiq。对于简单脚本，也可以用 while 循环配合 time.sleep。
状态存储：需要记录每次循环的状态、输入、输出、评估结果。简单的可以用文件（JSON）或SQLite数据库，复杂的可用 PostgreSQL、MySQL。

3. 硬件资源考量：

使用云端API：主要消耗是网络请求成本和API调用费用，对本地硬件要求低，只需能稳定运行Python脚本的环境。
使用本地模型：需要根据模型规模提供足够的GPU显存或CPU内存。这属于模型部署本身的资源需求，循环工程框架本身开销很小。

4. 系统架构设计与关键组件

在动手写代码之前，先设计一个清晰的架构。一个典型的循环工程系统包含以下核心组件，它们共同构成了一个“生产-消费-评估-优化”的闭环。

TEXT

[任务队列] -> [执行器 (LLM)] -> [输出] -> [评估器] -> [结果达标?]

^ |

| No

| [优化器] -> [更新Prompt/参数]

| |

+------------------------------------------------------+

1. 任务队列 (Task Queue)：

职责：接收初始任务（如“为以下产品写文案：{产品信息}”），并管理处于不同状态（待处理、执行中、待评估、已完成、失败）的任务。
实现：可以是Python的 queue.Queue（单进程），或使用 Redis、RabbitMQ 作为分布式消息队列。

2. 执行器 (Executor)：

职责：从队列中取出任务，调用大语言模型（LLM）或其它AI服务，生成初步结果。
关键：需要封装好与LLM的交互，处理API调用异常、超时、格式化Prompt模板。

3. 评估器 (Evaluator)：

职责：对执行器的输出进行质量评估。这是循环的“大脑”，决定了是否需要以及如何优化。
评估方式：
- 规则评估：通过正则表达式、关键词匹配、字符串长度、语法检查库（如language-tool-python）等进行硬性判断。速度快，确定性高。
- 模型评估：使用另一个LLM（可以是更小、更快的模型）作为裁判，根据指令（如“请从创意、通顺、合规三个维度评分，1-5分”）进行评估。更灵活，但成本更高且可能有波动。
- 混合评估：先通过规则过滤掉明显不合格项，再用模型进行精细评分。

4. 优化器 (Optimizer)：

职责：当评估器认为结果不达标时，负责分析原因并修改下一次执行的输入。这是循环的“优化引擎”。
优化策略：
- 提示词补全：在原有Prompt后追加指令，如“请确保包含‘限时优惠’这个词”。
- 提示词重写：让一个“优化专家”LLM根据失败原因和原始任务，完全重写一个新的Prompt。
- 参数调整：调整LLM的生成参数，如temperature（降低以减少随机性）、max_tokens（增加以生成更详细内容）。

5. 状态管理器 (State Manager)：

职责：持久化存储每个任务的生命周期数据，包括原始输入、历次循环的Prompt、输出、评估分数、优化历史等。用于监控、调试和事后分析。

5. 实战案例：构建一个AI文案自动质检与优化系统

让我们通过一个具体的简化案例，将上述架构落地。这个系统的目标是：自动生成产品文案，并确保其长度适中、包含指定关键词且语句通顺，不达标则自动优化重试。

场景设定：我们有一个商品列表，需要为每个商品生成一段约100字的推广文案，文案必须包含品牌名“TechGadget”和至少一个形容词。

5.1 系统初始化与配置

首先，我们定义核心的配置和数据结构。这里我们使用云端LLM API（以OpenAI为例）作为执行器。

PYTHON

# config.py

import os

from dataclasses import dataclass

from typing import List, Dict, Any

@dataclass

class Task:

"""代表一个待处理的任务"""

task_id: str

product_name: str

product_features: List[str]

original_prompt: str = ""

current_prompt: str = ""

outputs: List[str] = None # 历次输出

scores: List[Dict[str, float]] = None # 历次评估分数

status: str = "pending" # pending, running, evaluating, optimizing, completed, failed

final_output: str = ""

iteration: int = 0

max_iterations: int = 5 # 最大循环次数，防止无限循环

def __post_init__(self):

if self.outputs is None:

self.outputs = []

if self.scores is None:

self.scores = []

self.current_prompt = self.original_prompt

# 初始化任务列表（模拟队列）

task_queue: List[Task] = []

completed_tasks: List[Task] = []

# LLM配置（请替换为你的API Key）

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "your-api-key-here")

LLM_MODEL = "gpt-3.5-turbo" # 或 "gpt-4"

5.2 实现执行器 (Executor)

执行器负责调用LLM生成文案。

PYTHON

# executor.py

import openai

from config import OPENAI_API_KEY, LLM_MODEL

import logging

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger(__name__)

openai.api_key = OPENAI_API_KEY

def llm_generate(prompt: str, temperature: float = 0.7) -> str:

"""

调用LLM生成文本

"""

try:

response = openai.ChatCompletion.create(

model=LLM_MODEL,

messages=[{"role": "user", "content": prompt}],

temperature=temperature,

max_tokens=300,

)

return response.choices[0].message.content.strip()

except Exception as e:

logger.error(f"LLM调用失败: {e}")

raise

def execute_task(task: Task) -> str:

"""

执行任务：使用当前Prompt生成文案

"""

logger.info(f"执行任务 {task.task_id}, 迭代 {task.iteration}, Prompt: {task.current_prompt[:50]}...")

generated_text = llm_generate(task.current_prompt)

task.outputs.append(generated_text)

return generated_text

5.3 实现评估器 (Evaluator)

评估器包含三个检查规则，并给出一个综合评分。

PYTHON

# evaluator.py

import re

from typing import Tuple

def evaluate_output(output: str, product_name: str) -> Tuple[Dict[str, float], bool]:

"""

评估生成的文案。

返回: (评分字典, 是否通过)

评分规则：

1. 长度得分 (0-1): 目标100字，±20字内得1分，否则按比例扣分。

2. 关键词得分 (0-1): 必须包含"TechGadget"。包含得1分，否则0分。

3. 形容词得分 (0-1): 至少包含一个形容词（简单通过词库判断）。包含得1分，否则0分。

综合得分 >= 2.5 且关键词得分必须为1 则通过。

"""

scores = {}

# 1. 长度得分

word_count = len(output.split())

target_length = 100

length_diff = abs(word_count - target_length)

if length_diff <= 20:

scores['length'] = 1.0

else:

scores['length'] = max(0, 1.0 - (length_diff - 20) / 80) # 线性扣分

# 2. 关键词得分

mandatory_keyword = "TechGadget"

if mandatory_keyword.lower() in output.lower():

scores['keyword'] = 1.0

else:

scores['keyword'] = 0.0

# 3. 形容词得分 (简易判断)

adjective_list = ["创新的", "强大的", "高效的", "精致的", "可靠的", "时尚的", "便捷的"]

has_adj = any(adj in output for adj in adjective_list)

scores['adjective'] = 1.0 if has_adj else 0.0

# 计算综合得分

total_score = sum(scores.values())

# 通过条件：综合分>=2.5 且关键词必须存在

is_passed = (total_score >= 2.5) and (scores['keyword'] == 1.0)

return scores, is_passed

5.4 实现优化器 (Optimizer)

优化器根据评估结果，动态构建新的Prompt。

PYTHON

# optimizer.py

def optimize_prompt(task: Task, last_output: str, last_scores: Dict[str, float]) -> str:

"""

根据上一次的输出和评分，优化Prompt。

"""

base_instruction = f"为产品'{task.product_name}'撰写一段约100字的推广文案，突出其特点：{', '.join(task.product_features)}。"

feedback_parts = []

# 根据低分项添加反馈

if last_scores.get('length', 1) < 0.8:

current_length = len(last_output.split())

if current_length < 80:

feedback_parts.append("文案过于简短，请扩充内容，使其更丰富。")

else:

feedback_parts.append("文案过长，请精简语句，聚焦核心卖点。")

if last_scores.get('keyword', 0) == 0:

feedback_parts.append("文案中必须明确包含品牌名 'TechGadget'。")

if last_scores.get('adjective', 0) == 0:

feedback_parts.append("请使用积极、正面的形容词来描述产品，例如‘创新的’、‘高效的’。")

if feedback_parts:

feedback = "上一轮文案未完全满足要求，请参考以下意见修改：\n" + "\n".join(feedback_parts)

new_prompt = f"{base_instruction}\n\n{feedback}\n请生成新的文案。"

else:

# 如果分数都不错但未达标（可能其他规则），给予通用优化指令

new_prompt = f"{base_instruction}\n\n请使文案更具吸引力和说服力。"

return new_prompt

5.5 主循环引擎

将以上组件串联起来，形成主循环。

PYTHON

# main_loop.py

import time

from config import Task, task_queue, completed_tasks

from executor import execute_task

from evaluator import evaluate_output

from optimizer import optimize_prompt

import logging

logger = logging.getLogger(__name__)

def process_task(task: Task):

"""处理单个任务，直到完成或达到最大迭代次数"""

while task.iteration < task.max_iterations and task.status != "completed":

task.iteration += 1

task.status = "running"

# 1. 执行

try:

output = execute_task(task)

except Exception as e:

logger.error(f"任务 {task.task_id} 第 {task.iteration} 次执行失败: {e}")

task.status = "failed"

break

# 2. 评估

task.status = "evaluating"

scores, is_passed = evaluate_output(output, task.product_name)

task.scores.append(scores)

logger.info(f"任务 {task.task_id} 第 {task.iteration} 轮评估分数: {scores}, 通过: {is_passed}")

# 3. 判断

if is_passed:

task.status = "completed"

task.final_output = output

logger.info(f"任务 {task.task_id} 在第 {task.iteration} 轮完成！")

break

else:

# 4. 优化 (如果还有机会)

if task.iteration < task.max_iterations:

task.status = "optimizing"

new_prompt = optimize_prompt(task, output, scores)

task.current_prompt = new_prompt

logger.info(f"任务 {task.task_id} 优化Prompt，进入下一轮。")

time.sleep(1) # 避免频繁调用API

else:

task.status = "failed"

logger.warning(f"任务 {task.task_id} 达到最大迭代次数仍未通过。")

break

# 循环结束，记录最终状态

if task.status == "completed":

completed_tasks.append(task)

else:

logger.error(f"任务 {task.task_id} 最终状态: {task.status}")

def main():

# 模拟创建两个初始任务

initial_tasks = [

Task(

task_id="task_001",

product_name="智能无线耳机",

product_features=["主动降噪", "30小时续航", "蓝牙5.3"],

original_prompt="为产品‘智能无线耳机’撰写一段推广文案，介绍其主动降噪、30小时续航和蓝牙5.3的特点。"

Task(

task_id="task_002",

product_name="4K超清显示器",

product_features=["HDR600认证", "144Hz刷新率", "IPS面板"],

original_prompt="写一段关于‘4K超清显示器’的销售文案，提到HDR600、144Hz和IPS面板。"

)

]

task_queue.extend(initial_tasks)

logger.info("开始处理任务队列...")

for task in task_queue[:]: # 遍历副本

process_task(task)

logger.info("所有任务处理完毕。")

# 打印结果摘要

for task in completed_tasks:

print(f"\n=== 任务 {task.task_id} ===")

print(f"产品: {task.product_name}")

print(f"最终状态: {task.status}")

print(f"迭代次数: {task.iteration}")

print(f"最终文案:\n{task.final_output}\n")

if __name__ == "__main__":

main()

运行这个脚本，你将看到系统为两个产品自动生成文案，并根据我们设定的规则（长度、关键词、形容词）进行评估和优化，直到产出合格文案或达到最大重试次数。

6. 接口API与批量任务管理

上述案例是在一个脚本内同步运行的。对于生产环境，我们需要将其服务化，并支持真正的批量任务。

6.1 设计REST API接口

使用 FastAPI 可以快速构建任务提交和查询接口。

PYTHON

# api_server.py

from fastapi import FastAPI, BackgroundTasks

from pydantic import BaseModel

from typing import List, Optional

import uuid

from your_loop_engine import Task, process_task_async # 假设有异步处理函数

import asyncio

app = FastAPI()

# 内存中存储任务状态（生产环境应用数据库）

tasks_db = {}

class TaskRequest(BaseModel):

product_name: str

product_features: List[str]

original_prompt: Optional[str] = None

class TaskResponse(BaseModel):

task_id: str

status: str

final_output: Optional[str] = None

iteration: Optional[int] = None

@app.post("/api/v1/generate", response_model=TaskResponse)

async def create_generation_task(request: TaskRequest, background_tasks: BackgroundTasks):

"""提交一个新的文案生成任务"""

task_id = str(uuid.uuid4())[:8]

original_prompt = request.original_prompt or f"为产品‘{request.product_name}’撰写推广文案，特点：{', '.join(request.product_features)}。"

new_task = Task(

task_id=task_id,

product_name=request.product_name,

product_features=request.product_features,

original_prompt=original_prompt

)

tasks_db[task_id] = new_task

# 将任务加入后台处理队列

background_tasks.add_task(process_task_async, new_task)

return TaskResponse(task_id=task_id, status="submitted")

@app.get("/api/v1/task/{task_id}", response_model=TaskResponse)

async def get_task_status(task_id: str):

"""查询任务状态和结果"""

task = tasks_db.get(task_id)

if not task:

return {"error": "Task not found"}

return TaskResponse(

task_id=task.task_id,

status=task.status,

final_output=task.final_output,

iteration=task.iteration

)

# 启动命令：uvicorn api_server:app --host 0.0.0.0 --port 8000

6.2 集成任务队列（Celery示例）

对于大规模批量任务，使用Celery进行分布式异步处理是更稳健的方案。

PYTHON

# celery_app.py

from celery import Celery

from your_loop_engine import Task, process_task # 导入之前的处理函数

# 使用Redis作为消息代理

app = Celery('loop_worker', broker='redis://localhost:6379/0', backend='redis://localhost:6379/0')

@app.task(bind=True)

def run_loop_engine(self, task_data: dict):

"""Celery任务：执行循环引擎"""

task = Task(**task_data)

process_task(task) # 调用同步处理函数

return {

'task_id': task.task_id,

'status': task.status,

'final_output': task.final_output,

'iteration': task.iteration

}

# 提交批量任务

from celery_app import run_loop_engine

task_list = [...] # 你的任务字典列表

for t in task_list:

run_loop_engine.delay(t) # 任务被发送到队列，由Worker异步执行

这样，你可以通过API提交成千上万个任务，Worker会在后台持续消费队列，实现“通宵自我进化”。

7. 资源占用与性能观察

循环工程系统的性能瓶颈主要在于LLM调用和评估逻辑。

LLM API调用：
- 成本：主要成本是API调用次数（Tokens费用）。循环会导致调用次数成倍增加，需设置合理的 max_iterations 和评估标准，避免无意义循环。
- 速率限制：注意云服务的Rate Limit，需要在代码中实现退避重试机制（如指数退避）。
- 延迟：每次循环都包含网络往返时间，总处理时间 ≈ 迭代次数 × (LLM生成延迟 + 评估延迟)。
本地模型部署：
- 显存/内存：如果评估器也使用LLM，则需要同时加载执行和评估两个模型，显存占用会翻倍。考虑使用量化的小模型作为评估器。
- 计算开销：持续运行本地模型，GPU利用率会保持高位，需关注散热和功耗。
监控指标：
- 循环次数分布：统计大部分任务经过几次迭代后成功。这有助于优化评估标准和初始Prompt。
- 失败原因分析：记录任务最终失败的原因（如始终缺少关键词、长度不达标），用于迭代改进系统规则。
- 平均处理时间：监控单个任务从提交到完成的平均耗时，评估系统效率。

8. 常见问题与排查方法

问题现象	可能原因	排查方式	解决方案
任务陷入无限循环	1. 评估标准过于严苛或逻辑错误，永远无法通过。 2. 优化器生成的Prompt无法有效改进输出。	1. 检查评估器 `evaluate_output` 函数的通过逻辑。 2. 打印每次循环的输入Prompt、输出和评分，分析优化方向是否错误。	1. 调整评估阈值，或加入“迭代超过N次后，接受当前最佳结果”的降级策略。 2. 优化优化器逻辑，让其反馈更具体、可执行。
LLM API调用频繁失败	1. API Key无效或额度不足。 2. 网络问题。 3. 请求速率超限。	1. 检查API Key和环境变量。 2. 捕获异常并打印错误信息。 3. 查看云服务商控制台的用量和报错。	1. 更换有效的API Key。 2. 实现重试机制（如 `tenacity` 库）。 3. 在代码中加入延迟，控制请求频率。
评估结果不一致	1. 规则评估存在边界情况漏洞。 2. 使用LLM作为评估器时，其输出具有随机性。	1. 对大量样本运行评估器，统计通过率，检查误判/漏判。 2. 固定LLM评估器的seed，或使用多个评估并取多数票。	1. 完善规则，考虑更多边缘情况。 2. 对于关键评估，优先使用确定性高的规则评估。LLM评估可作为辅助或用于复杂维度。
系统处理速度慢	1. 串行处理任务。 2. LLM响应慢。 3. 评估逻辑复杂。	1. 使用 `concurrent.futures` 或 `asyncio` 实现并发。 2. 监控每个环节耗时。 3. 分析性能瓶颈。	1. 引入任务队列（Celery）实现并行处理。 2. 考虑使用响应更快的模型（如GPT-3.5 Turbo vs GPT-4）。 3. 优化评估器代码，或将其异步化。
优化后效果反而变差	优化指令与原始任务冲突，或让LLM产生困惑。	对比优化前后的Prompt和输出，分析指令是否清晰、无歧义。	简化优化指令，一次只针对一个最严重的问题进行修正。或让优化器LLM生成更自然的指令改写。

9. 最佳实践与使用建议

从小处着手，迭代验证：不要一开始就设计复杂的多维度评估和优化。先从1-2个核心、可量化的评估标准（如“必须包含某个关键词”）开始，跑通整个循环流程，再逐步增加复杂度。
设置安全护栏：
- 最大迭代次数：必须设置，防止无限循环消耗资源。
- 超时控制：对LLM调用和每个任务总时长设置超时。
- 内容安全过滤：在评估环节或最终输出前，加入对暴力、偏见、违规信息的过滤。
日志与可观测性：详细记录每个任务的完整生命周期日志（输入、每次循环的输出、评分、优化动作）。这是调试和优化系统最重要的依据。考虑结构化日志（如JSON格式），便于后续分析。
人工审核回路：对于重要或敏感任务，设计“人工审核”作为循环的一环。当系统迭代N次后仍不达标，或置信度低于某个阈值时，将任务挂起并通知人工处理。
版本化与实验管理：将你的评估器、优化器、Prompt模板进行版本控制。当你想尝试新的优化策略时，可以轻松进行A/B测试，比较不同版本在任务通过率和迭代次数上的表现。
成本意识：密切监控API调用量和费用。对于内部测试，可以使用更便宜的模型或本地模型。评估环节尽量使用轻量级规则，减少对昂贵LLM的调用。

10. 总结与下一步

循环工程将AI从“一次性的提示词执行者”升级为“拥有目标驱动和自省能力的自动化助手”。它的价值不在于替代人类创作，而在于处理那些量大、规则相对明确、但需要一定灵活性的重复性劳动。

通过本文的案例，你应该已经掌握了构建一个简易循环系统的核心步骤：定义任务、实现执行、评估、优化三个核心组件，并用一个主循环将其串联。最关键的是评估标准的设计和优化策略的有效性，这决定了循环是“智能进化”还是“无效空转”。

下一步，你可以尝试：

替换更强大的评估器：集成语法检查库、情感分析模型，甚至训练一个专门用于质量打分的微调模型。
实现更智能的优化器：让优化器本身也是一个LLM，根据评估结果和任务历史，自主决定如何修改Prompt或生成参数。
构建可视化监控面板：使用 Grafana 或 Streamlit 实时展示任务队列状态、循环次数分布、成功率等指标。
探索多智能体协作：将执行、评估、优化分别设计成独立的“智能体”，让它们通过共享状态或消息进行协作，架构会更清晰，也更容易扩展。

掌握循环工程，意味着你开始以系统化和工程化的思维运用AI，这才是超越单纯编写Prompt的下一站。建议从本文的简化案例开始，亲手实现一遍，理解其中的数据流和控制逻辑，然后将其应用到你自己面临的具体任务中去。