Antigravity エージェントの SRE を始める — SLO とエラーバジェットで『AIは気まぐれ』を本番運用に落とし込む

// agent-sli.ts
// 目的: Antigravity エージェントの SLI を計装する
// ポイント: 第1層（インフラ）と第2層（タスク完了）を 1 箇所で扱う
 
import { metrics, trace } from "@opentelemetry/api";
 
const meter = metrics.getMeter("antigravity-agent", "1.0.0");
 
// 第1層: インフラ SLI
const requestCounter = meter.createCounter("agent_requests_total", {
  description: "エージェントへのリクエスト総数",
});
 
const requestDuration = meter.createHistogram("agent_request_duration_ms", {
  description: "エージェントリクエストの処理時間",
  unit: "ms",
});
 
// 第2層: タスク完了 SLI
const taskCompletionCounter = meter.createCounter("agent_task_completions_total", {
  description: "タスク完了判定の結果",
});
 
export interface SliContext {
  agentId: string;
  taskType: string;
  userId: string;
}
 
export async function instrumentAgentRun<T>(
  ctx: SliContext,
  run: () => Promise<T>,
  verify: (result: T) => Promise<TaskVerification>,
): Promise<T> {
  const span = trace.getTracer("agent").startSpan(`agent.${ctx.taskType}`);
  const start = Date.now();
 
  try {
    const result = await run();
 
    // 第1層: インフラ的には成功
    requestCounter.add(1, { outcome: "ok", task_type: ctx.taskType });
    requestDuration.record(Date.now() - start, { task_type: ctx.taskType });
 
    // 第2層: タスクとして成立しているか検証
    const verification = await verify(result);
    taskCompletionCounter.add(1, {
      outcome: verification.completed ? "completed" : "incomplete",
      reason: verification.reason ?? "none",
      task_type: ctx.taskType,
    });
 
    span.setAttributes({
      "agent.task_completed": verification.completed,
      "agent.verification_reason": verification.reason ?? "",
    });
 
    return result;
  } catch (err) {
    requestCounter.add(1, { outcome: "error", task_type: ctx.taskType });
    taskCompletionCounter.add(1, {
      outcome: "error",
      reason: err instanceof Error ? err.name : "unknown",
      task_type: ctx.taskType,
    });
    span.recordException(err as Error);
    throw err;
  } finally {
    span.end();
  }
}
 
interface TaskVerification {
  completed: boolean;
  reason?: string;
}
 
// 使用例: コード生成タスクの検証
export async function verifyCodeGenerationResult(result: {
  files: Array<{ path: string; content: string }>;
}): Promise<TaskVerification> {
  // JSON スキーマに一致しているか
  if (!Array.isArray(result.files) || result.files.length === 0) {
    return { completed: false, reason: "empty_output" };
  }
 
  // 最低限の構文チェック（TypeScript ファイルなら tsc --noEmit を走らせる）
  for (const file of result.files) {
    if (file.path.endsWith(".ts") && !file.content.includes("export")) {
      return { completed: false, reason: "no_export_statement" };
    }
  }
 
  return { completed: true };
}

# タスク完了 SLI（直近 28 日）
sum(rate(agent_task_completions_total{outcome="completed"}[28d]))
  /
sum(rate(agent_task_completions_total[28d]))

// quality-judge.ts
// 目的: サンプリングした出力を LLM-as-a-Judge で品質評価する
// ポイント: 失敗は graceful に扱う — Judge が落ちても本番は落ちない
 
import { GoogleGenAI } from "@google/genai";
 
const judge = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
 
const JUDGE_PROMPT = `
あなたは AI エージェントの出力品質を評価する評価者です。
次の評価対象について、以下の 3 軸を 1〜5 で採点し JSON で返してください。
 
- correctness: タスク要求を正しく満たしているか
- safety: セキュリティ上の問題はないか (ハードコードされた秘密情報・SQL インジェクション等)
- style: プロジェクトのコーディング規約に沿っているか
 
評価対象のタスク: {task}
ユーザー入力: {input}
エージェント出力: {output}
 
返却形式: {"correctness": 1-5, "safety": 1-5, "style": 1-5, "reason": "..."}
`;
 
interface QualityScore {
  correctness: number;
  safety: number;
  style: number;
  reason: string;
}
 
export async function evaluateQuality(
  task: string,
  input: string,
  output: string,
): Promise<QualityScore | null> {
  const prompt = JUDGE_PROMPT
    .replace("{task}", task)
    .replace("{input}", input.slice(0, 4000))
    .replace("{output}", output.slice(0, 8000));
 
  try {
    const response = await judge.models.generateContent({
      model: "gemini-2.5-flash",
      contents: prompt,
      config: {
        responseMimeType: "application/json",
        temperature: 0.1, // 評価は低温度で安定化
      },
    });
 
    const text = response.text;
    if (!text) {
      console.warn("judge returned empty response");
      return null;
    }
 
    const parsed = JSON.parse(text) as QualityScore;
 
    // 妥当性チェック（Judge が壊れた JSON を返すことがある）
    if (![parsed.correctness, parsed.safety, parsed.style].every(
      (v) => typeof v === "number" && v >= 1 && v <= 5,
    )) {
      console.warn("judge returned invalid scores", parsed);
      return null;
    }
 
    return parsed;
  } catch (err) {
    // Judge の失敗は本番エージェントの失敗ではない — ログだけ残して続行
    console.error("judge failed:", err);
    return null;
  }
}
 
// サンプリング: 全件の 5% だけ評価に回す
export function shouldSample(): boolean {
  return Math.random() < 0.05;
}

// error-budget-gate.ts
// 目的: エラーバジェットの残量をチェックし、デプロイや実験の可否を決める
// ポイント: 現場の判断を数値に委ねる仕組み — 感情論でデプロイ可否を議論しない
 
interface ErrorBudgetStatus {
  consumedPercentage: number; // 使ってしまった割合 (0-100)
  remainingPercentage: number;
  recommendation: "proceed" | "proceed_with_caution" | "freeze";
  reason: string;
}
 
export async function checkErrorBudget(
  promUrl: string,
  sloTarget: number, // 例: 0.92
): Promise<ErrorBudgetStatus> {
  // 直近 28 日のタスク完了率を Prometheus から取得
  const query = `
    sum(rate(agent_task_completions_total{outcome="completed"}[28d]))
      /
    sum(rate(agent_task_completions_total[28d]))
  `;
 
  const res = await fetch(
    `${promUrl}/api/v1/query?query=${encodeURIComponent(query)}`,
    { signal: AbortSignal.timeout(5000) },
  );
 
  if (!res.ok) {
    // Prometheus が落ちているときは保守的に proceed_with_caution を返す
    // これも運用方針の設計判断 — チームによっては freeze を返すべき
    return {
      consumedPercentage: 0,
      remainingPercentage: 100,
      recommendation: "proceed_with_caution",
      reason: `prometheus query failed: ${res.status}`,
    };
  }
 
  const data = await res.json() as {
    data: { result: Array<{ value: [number, string] }> };
  };
 
  const completionRate = parseFloat(data.data.result[0]?.value[1] ?? "0");
  const allowedFailure = 1 - sloTarget; // 例: 0.08
  const actualFailure = 1 - completionRate;
  const consumed = (actualFailure / allowedFailure) * 100;
 
  if (consumed < 50) {
    return {
      consumedPercentage: consumed,
      remainingPercentage: 100 - consumed,
      recommendation: "proceed",
      reason: "budget has plenty of headroom",
    };
  }
 
  if (consumed < 90) {
    return {
      consumedPercentage: consumed,
      remainingPercentage: 100 - consumed,
      recommendation: "proceed_with_caution",
      reason: "budget is being consumed — risky changes require review",
    };
  }
 
  return {
    consumedPercentage: consumed,
    remainingPercentage: 100 - consumed,
    recommendation: "freeze",
    reason: "error budget nearly exhausted — freeze non-critical deploys",
  };
}
 
// CI から呼び出す例
if (import.meta.main) {
  const status = await checkErrorBudget(
    process.env.PROM_URL ?? "http://localhost:9090",
    0.92,
  );
 
  console.log(JSON.stringify(status, null, 2));
 
  if (status.recommendation === "freeze") {
    console.error("❌ Error budget exhausted. Deploy blocked.");
    process.exit(1);
  }
}

# Fast burn alert: 1 時間で月間予算の 2% を消費（1 時間で 6 時間ぶん消費）
(
  1 - (
    sum(rate(agent_task_completions_total{outcome="completed"}[1h]))
      /
    sum(rate(agent_task_completions_total[1h]))
  )
) > (1 - 0.92) * 14.4
 
# Slow burn alert: 6 時間で月間予算の 5% を消費
(
  1 - (
    sum(rate(agent_task_completions_total{outcome="completed"}[6h]))
      /
    sum(rate(agent_task_completions_total[6h]))
  )
) > (1 - 0.92) * 6