Claude 递归自我改进实战：用 API 构建会自我优化的 Agent

用户6064876718896
2 阅读1分钟

Claude 递归自我改进实战：用 API 构建会自我优化的 Agent

昨天 Anthropic 的递归自我改进技术登上了《时代》杂志封面，这项技术让 AI 能够通过不断试错来优化自己的行为。今天我们用 Claude API 实现一个最小化的递归改进 Agent，看看这个技术到底怎么玩。

什么是递归自我改进？

简单说就是：AI 执行任务 → 评估结果 → 发现问题 → 改进策略 → 再次执行。这个循环可以让 Agent 在没有人工干预的情况下越来越聪明。

核心流程：

  1. 执行：Agent 尝试完成任务
  2. 评估：检查结果是否符合预期
  3. 反思：分析失败原因
  4. 改进：调整 prompt 或策略
  5. 重试：用新策略再次执行

最小化实现（50 行代码）

我们用 Claude API 实现一个会自我改进的代码生成器。

import anthropic
import json

client = anthropic.Anthropic(
    api_key="你的API密钥",
    base_url="https://xingjiabiapi.org/v1"  # 国内直连
)

def recursive_agent(task, max_iterations=3):
    """递归自我改进 Agent"""
    history = []  # 记录每次尝试
    
    for i in range(max_iterations):
        print(f"\n=== 第 {i+1} 次尝试 ===")
        
        # 构建 prompt（包含历史失败经验）
        prompt = build_prompt(task, history)
        
        # 执行任务
        response = client.messages.create(
            model="claude-opus-4-6",
            max_tokens=2000,
            messages=[{"role": "user", "content": prompt}]
        )
        
        result = response.content[0].text
        
        # 评估结果
        evaluation = evaluate_result(result, task)
        
        if evaluation["success"]:
            print("✅ 任务成功！")
            return result
        
        # 记录失败经验
        history.append({
            "attempt": i + 1,
            "result": result,
            "error": evaluation["error"]
        })
        
        print(f"❌ 失败：{evaluation['error']}")
    
    return None

def build_prompt(task, history):
    """根据历史失败经验构建 prompt"""
    base = f"任务：{task}\n\n"
    
    if history:
        base += "之前的失败尝试：\n"
        for h in history:
            base += f"- 第 {h['attempt']} 次：{h['error']}\n"
        base += "\n请根据上述失败经验改进你的方案。\n"
    
    return base

def evaluate_result(result, task):
    """评估结果是否符合预期"""
    # 这里用另一个 Claude 调用来评估
    eval_prompt = f"""
任务要求：{task}

生成的结果：
{result}

请评估这个结果是否完成了任务。
返回 JSON 格式：{{"success": true/false, "error": "失败原因"}}
"""
    
    response = client.messages.create(
        model="claude-sonnet-4",  # 用便宜的模型做评估
        max_tokens=200,
        messages=[{"role": "user", "content": eval_prompt}]
    )
    
    return json.loads(response.content[0].text)

# 测试
task = "写一个 Python 函数，计算斐波那契数列第 n 项，要求时间复杂度 O(n)"
result = recursive_agent(task)
print("\n最终结果：")
print(result)

运行效果

=== 第 1 次尝试 ===
❌ 失败：使用了递归实现，时间复杂度是 O(2^n)

=== 第 2 次尝试 ===
❌ 失败：没有处理 n=0 的边界情况

=== 第 3 次尝试 ===
✅ 任务成功！

最终结果：
def fibonacci(n):
    if n == 0:
        return 0
    if n == 1:
        return 1
    
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

进阶：记忆持久化

上面的实现只在单次运行中有效，重启后就忘了。我们可以把历史经验存到文件里：

import json
from pathlib import Path

MEMORY_FILE = "agent_memory.json"

def load_memory():
    """加载历史经验"""
    if Path(MEMORY_FILE).exists():
        with open(MEMORY_FILE) as f:
            return json.load(f)
    return {}

def save_memory(task, history):
    """保存历史经验"""
    memory = load_memory()
    memory[task] = history
    with open(MEMORY_FILE, 'w') as f:
        json.dump(memory, f, indent=2)

def recursive_agent_with_memory(task, max_iterations=3):
    """带记忆的递归 Agent"""
    memory = load_memory()
    history = memory.get(task, [])  # 加载该任务的历史经验
    
    # ... 其他代码同上 ...
    
    save_memory(task, history)  # 保存经验
    return result

现在 Agent 会记住之前犯过的错误，下次遇到类似任务时直接避开。

成本优化技巧

递归改进会多次调用 API，成本是个问题。这里有几个省钱方法：

  1. 评估用便宜模型：执行用 Opus，评估用 Sonnet
  2. 限制迭代次数：设置 max_iterations=3
  3. 用中转站：xingjiabiapi.org 的 Claude Opus 4.6 比官方便宜 48%

成本对比（生成 1000 tokens）：

  • 官方 Opus：15/Mtokens=15/M tokens = 0.015
  • 中转站 Opus：¥31.50/M tokens = $0.0078（省 48%）

实际应用场景

这个模式适合：

  • 代码生成：自动修复语法错误、优化性能
  • 文案优化：根据反馈不断改进文案质量
  • 数据处理：自动调整清洗规则
  • 测试用例生成：根据覆盖率反馈补充用例

完整代码

GitHub 仓库：github.com/sxl7530-has…

包含：

  • 基础递归 Agent
  • 带记忆持久化版本
  • 多任务并行版本
  • 成本统计工具

总结

递归自我改进的核心是"试错 + 反思 + 改进"循环。用 Claude API 实现起来很简单，关键是设计好评估机制。

这个技术还在早期阶段，但潜力巨大。想象一下：未来的 AI 助手不需要你反复调教，它会自己学习你的偏好，越用越懂你。

本文代码基于 Claude Opus 4.6 测试通过。

avatar
文章
阅读
粉丝