verification-loops

验证循环

Agent Skills™ 的一部分，由 googleadsagent.ai™ 提供

描述

验证循环是一种系统化评估流水线，可在执行的每个阶段验证 Agent 的输出。自主 Agent 面临的根本挑战是信任——如何确定 Agent 做对了？验证循环通过在 Agent 的执行流水线中嵌入检查点评估、持续断言和多阶段审核关卡来解决这一问题。本技能借鉴了 googleadsagent.ai™ 在生产环境中采用的评估方法：Buddy™ 会在向用户展示每项 Google Ads 建议前，根据历史数据、预算限制和领域规则进行验证。

检查点验证与持续验证之间的区别至关重要。检查点验证会在指定的阶段边界（提交前、分析后、部署前）评估输出。持续验证则在生成过程中实时运行断言，在偏差和幻觉扩散之前将其捕获。两种方法都可结合 pass@k 指标：生成多个候选输出，并根据评估器共识选出最佳结果。

生产环境中的验证系统会采用类型化评估器：用于验证架构和约束的确定性评估器、用于评估语义质量的 LLM-as-judge 评估器，以及用于高风险决策的人机协同评估器。这些方法结合起来形成分层验证网，能在流水线中最早、成本最低的环节捕获错误。

适用场景

• Agent 输出会直接影响业务决策或面向用户的内容
• 监管或合规要求需要为 AI 生成的内容保留审计记录
• 多步骤工作流需要在阶段之间设置质量关卡
• 你需要衡量并持续提升 Agent 的准确率（pass@k 基准测试）
• 生成的代码必须通过测试后才能提交或部署
• 分析结果必须根据真实情况或业务规则进行验证

工作原理

graph TD
    A[Agent Output] --> B[Stage 1: Deterministic Grader]
    B -->|Pass| C[Stage 2: LLM-as-Judge]
    B -->|Fail| D[Reject + Feedback Loop]
    C -->|Pass| E[Stage 3: Confidence Scoring]
    C -->|Fail| D
    E -->|High Confidence| F[Accept Output]
    E -->|Low Confidence| G{pass@k Available?}
    G -->|Yes| H[Generate k Candidates]
    H --> I[Rank by Grader Consensus]
    I --> F
    G -->|No| J[Human-in-the-Loop Review]
    J --> F
    D --> K[Error Context Injection]
    K --> L[Re-generation with Feedback]
    L --> B

验证流水线会通过三个阶段处理每项 Agent 输出。阶段 1 应用确定性评估器——架构验证、约束检查、类型验证——这些评估快速且成本低。阶段 2 调用 LLM-as-judge，评估语义正确性、完整性和连贯性。阶段 3 根据各评估器的综合信号计算置信度分数。低置信度输出会触发 pass@k 生成，即生成多个候选结果，并根据评估器共识进行排序。被拒绝的输出会收到具体错误反馈，并将其注入重新生成提示词。

实现

多阶段验证流水线：

interface Grader {
  name: string;
  type: "deterministic" | "llm_judge" | "human";
  evaluate(output: string, context: VerificationContext): Promise<GradeResult>;
}

interface GradeResult {
  pass: boolean;
  score: number;
  feedback: string;
}

class VerificationPipeline {
  private stages: Grader[][] = [];

  addStage(graders: Grader[]): void {
    this.stages.push(graders);
  }

  async verify(output: string, context: VerificationContext): Promise<VerificationResult> {
    const stageResults: StageResult[] = [];

    for (const [idx, graders] of this.stages.entries()) {
      const grades = await Promise.all(
        graders.map(g => g.evaluate(output, context))
      );
      const stagePassed = grades.every(g => g.pass);
      const stageScore = grades.reduce((sum, g) => sum + g.score, 0) / grades.length;

      stageResults.push({ stage: idx, grades, passed: stagePassed, score: stageScore });

      if (!stagePassed) {
        return {
          accepted: false,
          stageResults,
          feedback: grades.filter(g => !g.pass).map(g => g.feedback).join("\n"),
        };
      }
    }

    const confidence = stageResults.reduce((sum, s) => sum + s.score, 0) / stageResults.length;
    return { accepted: true, stageResults, confidence };
  }
}

Pass@k 候选项选择：

async def pass_at_k(task, generator, verifier, k=5):
    """Generate k candidates and select the best by verification score."""
    candidates = await asyncio.gather(*[
        generator.generate(task) for _ in range(k)
    ])

    scored = []
    for candidate in candidates:
        result = await verifier.verify(candidate, task.context)
        scored.append({
            "output": candidate,
            "accepted": result.accepted,
            "confidence": result.confidence,
            "feedback": result.feedback,
        })

    accepted = [s for s in scored if s["accepted"]]
    if accepted:
        return max(accepted, key=lambda s: s["confidence"])

    return max(scored, key=lambda s: s["confidence"])

LLM-as-Judge 评估器：

class LLMJudgeGrader:
    JUDGE_PROMPT = """You are an expert evaluator. Assess the following agent output
against the given task requirements.

Task: {task}
Output: {output}
Criteria: {criteria}

Respond with JSON:
{{"pass": true/false, "score": 0.0-1.0, "feedback": "specific feedback"}}"""

    def __init__(self, judge_model, criteria):
        self.judge_model = judge_model
        self.criteria = criteria

    async def evaluate(self, output, context):
        prompt = self.JUDGE_PROMPT.format(
            task=context.task_description,
            output=output,
            criteria=self.criteria,
        )
        response = await self.judge_model.generate(prompt, temperature=0.0)
        return json.loads(response)

确定性架构评估器：

class SchemaGrader:
    def __init__(self, schema: dict):
        self.schema = schema

    async def evaluate(self, output, context):
        try:
            parsed = json.loads(output)
            jsonschema.validate(parsed, self.schema)
            return {"pass": True, "score": 1.0, "feedback": "Schema valid"}
        except jsonschema.ValidationError as e:
            return {"pass": False, "score": 0.0, "feedback": f"Schema violation: {e.message}"}
        except json.JSONDecodeError:
            return {"pass": False, "score": 0.0, "feedback": "Invalid JSON"}

最佳实践

1. 按成本排列评估器——先运行确定性（免费）评估器，再运行 LLM-as-judge（昂贵）评估器；大多数失败都能以较低成本捕获。
2. 让反馈具有可操作性——注入重新生成提示词的评估器反馈必须足够具体，以便指导修正（“缺少字段 X”，而不是“输出有误”）。
3. 跟踪各评估器的通过率——从不失败的评估器只会增加延迟而毫无价值；总是失败的评估器则表明提示词或模型存在问题。
4. 有策略地使用 pass@k——生成 5 个候选项会消耗 5 倍 Token；仅在准确性值得其成本的高价值输出中使用 pass@k。
5. 将验证模型与生成模型分开——使用不同的模型作为评判者，可减少相关错误，即同一模型犯下并忽略同一个错误的情况。
6. 实现验证缓存——相同任务的相同输出应直接返回缓存的验证结果，无需重新评估。
7. 针对不同用例设置置信度阈值——代码生成可能需要 0.95 的置信度；创意写作可能接受 0.7。

平台兼容性

功能	Claude Code	Cursor	Codex	Gemini CLI
确定性评分器	✅ 完整	✅ 完整	✅ 完整	✅ 完整
LLM 作为评判者	✅ 完整	✅ 通过 API	✅ 通过 API	✅ 通过 API
pass@k 生成	✅ 完整	✅ 子 Agent	✅ 完整	✅ 完整
提交前钩子	✅ 原生钩子	✅ Git 钩子	✅ Git 钩子	✅ Git 钩子
置信度评分	✅ 完整	✅ 完整	✅ 完整	✅ 完整

Mythos Preview 参考

Anthropic 的 Mythos Preview 流程以第二轮 Agent 审核收尾，其工作是分类，而非发现：他们会提示类似 “我收到以下错误报告。请确认这是否是真实且值得关注的问题？” 的内容，以筛除属实但影响较低的问题，保留严重且具有广泛相关性的问题。

将其用作验证 Agent模式：主 Agent 生成发现后，启动一次全新的审核，并提供相关产物、明确的质疑态度，以及针对“真实”“重要”和“可采取行动”的判断标准。来源：Mythos Preview。

相关技能

• 自我修复 Agent - 验证循环拒绝 Agent 输出时触发的错误恢复
• Agent 本能系统 - 在采取行动前进行验证，避免出现需要验证才能发现的错误
• 提示词架构 - 在提示词设计中强制执行架构，从而降低验证失败率

关键词

verification-loops, evaluation, graders, pass-at-k, llm-as-judge, confidence-scoring, checkpoint-verification, continuous-evaluation, quality-gates, agent-skills

---

© 2026 googleadsagent.ai™ | Agent Skills™ | MIT License