AI Coding 工程的
6 层演进

class AgentHarness:
    def __init__(self, llm, tools, permissions):
        self.llm = llm
        self.tools = ToolRegistry(tools)
        self.perms = PermissionLayer(permissions)
        self.state = StateStore()  # 持久化
        self.trace = Tracer()

    def run(self, task, max_steps=20):
        self.state.add("user", task)
        for step in range(max_steps):
            # ① 思考
            thought = self.llm.think(self.state.history)
            self.trace.log(step, "thought", thought)

            # ② 决策动作
            action = self.llm.decide(thought, self.tools.schemas())
            if action.type == "finish":
                return action.result

            # ③ 权限把关
            if not self.perms.allow(action, self.state.user):
                action = self.perms.ask_human(action)

            # ④ 执行 + 错误恢复
            try:
                observation = self.tools.call(action)
            except ToolError as e:
                observation = ErrorRecovery(e).handle(action)

            # ⑤ 更新状态
            self.state.add("assistant", thought, action)
            self.state.add("tool", observation)
            self.state.checkpoint()  # 每步存档

        raise MaxStepsError("循环未收敛")

class LoopAgent:
    def __init__(self, llm, tools, memory):
        self.llm, self.tools = llm, tools
        self.memory = Memory()  # 短期/工作/长期/情景
        self.checkpoint = CheckpointStore()

    def run(self, goal, max_iter=30):
        plan = self._plan(goal)        # Planner
        self.memory.short_term.add("goal", goal)
        self.memory.short_term.add("plan", plan)

        for it in range(max_iter):
            # ① 选择下一个子任务
            sub = self._select_next(plan, self.memory)
            if sub is None: break

            # ② 执行 + 观察
            action = self.llm.act(sub, self.memory.short_term)
            obs = self.tools.call(action)
            self.memory.short_term.add("obs", obs)
            self.checkpoint.save(self.memory)

            # ③ 反思 (Reflection)
            reflection = self.llm.reflect(sub, action, obs)
            if reflection.is_failure():
                plan = self._revise(plan, reflection)

            # ④ 长期记忆更新
            if obs.is_novel():
                self.memory.long_term.add(obs.summary)

            # ⑤ 收敛判断
            if self._is_goal_met(plan, self.memory):
                return self._compose_answer()

        raise UnfinishedError("达到迭代上限")

    def resume(self, ckpt_id):
        state = self.checkpoint.load(ckpt_id)
        self.memory = state.memory
        return self.run(state.remaining_goal)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
C · Capacity and Role  角色与能力
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

你是一位拥有 10 年经验的[领域]专家，
擅长把复杂概念讲给一线工程师听。

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
R · Request  任务陈述
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

请帮我写一篇关于 [主题] 的 [文体]，
目标读者是 [受众]，核心目的是 [目的]。

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
I · Insight  背景与上下文
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

背景：[领域现状 / 用户痛点 / 已有方案]
限制：[字数 / 风格 / 时间 / 预算]

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
S · Statement  输出要求
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

结构：[开头 / 主体 / 结尾 应包含哪些要素]
风格：[语言 / 节奏 / 称呼 / 段落长度]
长度：[字数范围 / 段落数]

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
P · Personality  个性化
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

语气应该像：[人物 / 文章 / 品牌的风格]
避免：[口癖 / 套话 / 偏见词]

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
E · Experiment  示例与反例
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

示例输入 1：[真实场景]
理想输出 1：[完整示例]
错误输出 → 修正：[反例 + 修正版]

import dspy

class QA(dspy.Signature):
    """给定问题，从上下文回答。"""
    question = dspy.InputField()
    context  = dspy.InputField()
    answer   = dspy.OutputField()

class CoT_QA(dspy.Module):
    def __init__(self):
        super().__init__()
        self.gen = dspy.ChainOfThought(QA)
    def forward(self, question, context):
        return self.gen(question=question, context=context)

agent = CoT_QA()
# 自动用 200 条标注做 BootstrapFewShot 优化
optimizer = dspy.BootstrapFewShot(metric=dspy.evaluate.answer_exact_match)
optimized = optimizer.compile(agent, trainset=trainset)

# 输出：新 prompt 比人手写的准确率高 +14%

# DeepSeek-R1 / GRPO 核心
for each prompt q:
  sample G responses {o_1, ..., o_G} from π_θ_old
  compute reward r_i for each o_i (e.g. 答案是否正确)
  advantage A_i = (r_i - mean(r)) / std(r)
  update θ to maximize:
    J(θ) = E[min(ρ_i·A_i, clip(ρ_i, 1-ε, 1+ε)·A_i)]
        - β · KL(π_θ || π_ref)
  where ρ_i = π_θ(o_i|q) / π_θ_old(o_i|q)

# 关键：去掉 critic 模型，纯组内相对优势
# 训练成本比 PPO 砍 ~50%