Antigravity Agent のフォールバック階層設計 — モデル劣化・API障害・コスト超過を 4 段で受け止める Resilience アーキテクチャ

// agent-tier0.ts — Primary 実行と健康度シグナル取得
import { AntigravityAgent, type ExecutionResult } from "@antigravity/agent";
import { healthScore } from "./health-score";
import { recordSpan } from "./observability";
 
export async function runTier0(prompt: string, ctx: AgentContext): Promise<ExecutionResult> {
  const span = recordSpan("agent.tier0", { model: "gemini-3-pro-thinking" });
  const started = Date.now();
  try {
    const result = await AntigravityAgent.run({
      model: "gemini-3-pro-thinking",
      prompt,
      tools: ctx.tools,
      maxOutputTokens: 4096,
      reasoningEffort: "high",
    });
    const latencyMs = Date.now() - started;
    const score = healthScore({
      latencyMs,
      tokensUsed: result.usage.totalTokens,
      finishReason: result.finishReason,
      validatorPassed: ctx.validate(result.output),
    });
    span.end({ ok: true, latencyMs, healthScore: score });
    ctx.healthBuffer.push(score);
    return result;
  } catch (err) {
    span.end({ ok: false, error: String(err) });
    throw err;
  }
}

// agent-tier1.ts — Degraded 実行
export async function runTier1(prompt: string, ctx: AgentContext): Promise<ExecutionResult> {
  const compressed = await compressPrompt(prompt, {
    targetRatio: 0.65,                  // 35% 圧縮
    preserveMarkers: ["<task>", "<constraint>"],
  });
  const span = recordSpan("agent.tier1", { model: "gemini-3-flash" });
  try {
    return await AntigravityAgent.run({
      model: "gemini-3-flash",
      prompt: compressed,
      tools: ctx.tools.slice(0, 5),     // ツール数を5個に絞る
      maxOutputTokens: 2048,
      reasoningEffort: "medium",
    });
  } finally {
    ctx.metrics.increment("agent.tier1.runs");
    span.end();
  }
}

// agent-tier2.ts — Local 推論
import { GemmaLocal } from "@antigravity/gemma-runtime";
 
export async function runTier2(prompt: string, ctx: AgentContext): Promise<ExecutionResult> {
  const span = recordSpan("agent.tier2", { model: "gemma-4-12b-q4" });
  const trimmed = await trimContextForLocal(prompt, {
    maxTokens: 8192,                    // ローカルの実用上限
    dropOptional: true,
  });
  try {
    const result = await GemmaLocal.run({
      modelPath: "/opt/gemma/gemma-4-12b-q4.gguf",
      prompt: trimmed,
      temperature: 0.2,
      maxOutputTokens: 1024,
    });
    return { ...result, degraded: true };
  } finally {
    span.end();
  }
}

// agent-tier3.ts — Cached/Static
import { SemanticCache } from "@antigravity/semantic-cache";
 
const STATIC_FALLBACKS: Record<string, string> = {
  "crashlytics-triage": JSON.stringify({
    summary: "サービス縮退中。優先度高クラッシュのみ最終応答を参照してください。",
    severity: "unknown",
    suggested_action: "manual_review_required",
  }),
  "admob-placement-optimizer": JSON.stringify({
    placement: "use_previous_24h_recommendation",
    confidence: 0.5,
    reason: "AI inference offline; falling back to last good config.",
  }),
};
 
export async function runTier3(prompt: string, ctx: AgentContext): Promise<ExecutionResult> {
  const hit = await SemanticCache.search(prompt, { threshold: 0.92, maxAgeDays: 30 });
  if (hit) {
    return { output: hit.response, source: "semantic-cache", degraded: true };
  }
  const staticResponse = STATIC_FALLBACKS[ctx.agentId];
  if (staticResponse) {
    return { output: staticResponse, source: "static-fallback", degraded: true };
  }
  return { output: "{}", source: "empty-fallback", degraded: true };
}

// tier-controller.ts — 階層遷移の判定
type TierLevel = 0 | 1 | 2 | 3;
 
interface TierSignals {
  burnRate: number;            // 月予算に対する消費ペース (1.0 = 100%)
  errorRate10min: number;      // 直近10分のエラー率 (0-1)
  healthScore20: number;       // 直近20件の健康度平均 (0-1)
  apiAvailable: boolean;       // 外部API疎通
  costCapExceeded: boolean;    // 月予算上限到達
}
 
export function decideTier(signals: TierSignals, current: TierLevel): TierLevel {
  // 強制 Tier 3 — 完全縮退
  if (signals.costCapExceeded) return 3;
  // 強制 Tier 2 — 外部API断
  if (!signals.apiAvailable) return 2;
  // 健康度深刻 — Tier 2 へ降格
  if (signals.healthScore20 < 0.60) return 2;
  // エラー率高 — Tier 1 へ降格（既に Tier 1/2 なら現状維持）
  if (signals.errorRate10min > 0.25 && current === 0) return 1;
  // Burn-Rate 高 — Tier 1 へ降格
  if (signals.burnRate > 1.10 && current === 0) return 1;
  // 健康度軽度劣化 — Tier 1 へ降格
  if (signals.healthScore20 < 0.80 && current === 0) return 1;
  // 復帰判定 — 健康度＋エラー率＋コストが安定したら 1 段昇格
  if (current > 0 &&
      signals.healthScore20 > 0.90 &&
      signals.errorRate10min < 0.05 &&
      signals.burnRate < 0.95) {
    return (current - 1) as TierLevel;
  }
  return current;
}