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

// agent-sli.ts
// 目的: エージェントの 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;
}
 
export interface TaskVerification {
  completed: boolean;
  reason?: 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();
  }
}
 
// コード生成タスクの検証例。型チェックは呼び出し側から注入する
export async function verifyCodeGenerationResult(
  result: { files: Array<{ path: string; content: string }> },
  deps: { typecheck: (files: Array<{ path: string; content: string }>) => Promise<boolean> },
): Promise<TaskVerification> {
  if (!Array.isArray(result.files) || result.files.length === 0) {
    return { completed: false, reason: "empty_output" };
  }
  if (result.files.some((f) => f.content.trim() === "")) {
    return { completed: false, reason: "empty_file" };
  }
  const tsFiles = result.files.filter((f) => f.path.endsWith(".ts"));
  if (tsFiles.length > 0 && !(await deps.typecheck(tsFiles))) {
    return { completed: false, reason: "typecheck_failed" };
  }
  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 で品質評価する
// ポイント: 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;
    const scores = [parsed.correctness, parsed.safety, parsed.style];
    if (!scores.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;
  }
}

// sampler.ts
// 目的: タスクタイプごとに「最低 N 件」を保証する層化サンプリング
 
const evaluatedCount = new Map<string, number>();
const MIN_PER_TYPE_PER_DAY = 5;
const BASE_RATE = 0.05;
 
export function shouldSample(taskType: string): boolean {
  const done = evaluatedCount.get(taskType) ?? 0;
  const pick = done < MIN_PER_TYPE_PER_DAY || Math.random() < BASE_RATE;
  if (pick) evaluatedCount.set(taskType, done + 1);
  return pick;
}
 
// 日次ジョブの先頭でカウンタをリセットする
export function resetDailyCounters(): void {
  evaluatedCount.clear();
}

// error-budget-gate.ts
// 目的: エラーバジェットの残量を見て、デプロイや実験の可否を判定する
// ポイント: 判断を数値に委ね、感情論でデプロイ可否を議論しない
 
export interface ErrorBudgetStatus {
  consumedPercentage: number; // 使った割合 (0 以上。100 超は超過)
  remainingPercentage: number; // 0 未満にはしない
  recommendation: "proceed" | "proceed_with_caution" | "freeze";
  reason: string;
}
 
const QUERY = `
  sum(rate(agent_task_completions_total{outcome="completed"}[28d]))
    /
  sum(rate(agent_task_completions_total[28d]))
`;
 
export async function checkErrorBudget(
  promUrl: string,
  sloTarget: number, // 例: 0.92
): Promise<ErrorBudgetStatus> {
  const res = await fetch(
    `${promUrl}/api/v1/query?query=${encodeURIComponent(QUERY)}`,
    { signal: AbortSignal.timeout(5000) },
  );
 
  if (!res.ok) {
    // Prometheus 障害時の扱いは運用方針そのもの。チームによっては 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] }> };
  };
 
  // 結果が空（計装直後・無トラフィック）や NaN のときに 0% と誤読しない
  const raw = data.data.result[0]?.value[1];
  const completionRate = raw === undefined ? NaN : parseFloat(raw);
  if (Number.isNaN(completionRate)) {
    return {
      consumedPercentage: 0,
      remainingPercentage: 100,
      recommendation: "proceed_with_caution",
      reason: "no data in window — cannot evaluate budget",
    };
  }
 
  const allowedFailure = 1 - sloTarget; // 例: 0.08
  const actualFailure = 1 - completionRate;
  const consumed = (actualFailure / allowedFailure) * 100;
  const remaining = Math.max(0, 100 - consumed);
 
  if (consumed < 50) {
    return { consumedPercentage: consumed, remainingPercentage: remaining,
      recommendation: "proceed", reason: "budget has plenty of headroom" };
  }
  if (consumed < 90) {
    return { consumedPercentage: consumed, remainingPercentage: remaining,
      recommendation: "proceed_with_caution",
      reason: "budget is being consumed — risky changes require review" };
  }
  return { consumedPercentage: consumed, remainingPercentage: remaining,
    recommendation: "freeze",
    reason: "error budget nearly exhausted — freeze non-critical deploys" };
}

// check-budget-cli.ts
import { checkErrorBudget } from "./error-budget-gate";
 
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);
}

// burn-table.mjs — node burn-table.mjs 0.92
const slo = Number(process.argv[2] ?? 0.92);
const budget = 1 - slo;
const monthHours = 720;
 
console.log(`max burn rate = ${(1 / budget).toFixed(2)}`);
for (const [name, burn, windowH] of [["page", 6, 1], ["ticket", 3, 6], ["slow", 1, 72]]) {
  const failure = burn * budget;
  const used = ((burn * windowH) / monthHours) * 100;
  console.log(`${name}: burn=${burn} window=${windowH}h failure>${(failure * 100).toFixed(1)}% budget=${used.toFixed(2)}%`
    + (failure >= 1 ? "  ← 到達不能" : ""));
}

# agent-slo-rules.yml（抜粋。1h・6h・30m・3d も同じ形で定義します）
groups:
  - name: agent-slo-recording
    rules:
      - record: agent:task_failure_ratio:rate5m
        expr: |
          1 - (
            sum(rate(agent_task_completions_total{outcome="completed"}[5m]))
            /
            sum(rate(agent_task_completions_total[5m]))
          )
      - record: agent:task_failure_ratio:rate1h
        expr: |
          1 - (
            sum(rate(agent_task_completions_total{outcome="completed"}[1h]))
            /
            sum(rate(agent_task_completions_total[1h]))
          )
 
  - name: agent-slo-alerts
    rules:
      - alert: AgentErrorBudgetBurnPage
        expr: |
          agent:task_failure_ratio:rate1h > (6 * 0.08)
          and
          agent:task_failure_ratio:rate5m > (6 * 0.08)
          and
          sum(rate(agent_task_completions_total[1h])) > 0.01
        for: 2m
        labels:
          severity: page
        annotations:
          summary: "このペースだと約 5 日でバジェットを使い切ります（SLO 92%）"