Antigravity × AgentKit 2.0 × Gemma 4: Cut API Costs by 80% with a Local Multi-Agent System in Production

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh
 
# Pull the Gemma 4 8B model (~5.2 GB)
ollama pull gemma4:8b
 
# Verify it works
ollama run gemma4:8b "Write a TypeScript fibonacci function"
 
# Start as an API server (required for AgentKit)
OLLAMA_HOST=0.0.0.0:11434 ollama serve

# Set in ~/.ollama/config or as environment variables
export OLLAMA_NUM_PARALLEL=4       # Concurrent session limit
export OLLAMA_MAX_LOADED_MODELS=2  # Models to keep in RAM

import { AgentKit, Agent, AgentGraph } from "@google/agentkit";
import { Ollama } from "ollama";
import { GoogleGenerativeAI } from "@google/generative-ai";
 
const ollamaClient = new Ollama({ host: "http://localhost:11434" });
const geminiClient = new GoogleGenerativeAI(process.env.GEMINI_API_KEY\!);
 
const LOCAL_MODEL = "gemma4:8b";
const CLOUD_MODEL = "gemini-2.5-flash"; // Flash for cost efficiency
 
const agentKit = new AgentKit({
  projectId: process.env.GOOGLE_CLOUD_PROJECT,
  location: "us-central1",
});

{
  "version": "2.0",
  "agents": [
    {
      "id": "router",
      "name": "Task Router",
      "model": "gemma4:8b",
      "endpoint": "http://localhost:11434"
    },
    {
      "id": "code-reviewer",
      "name": "Code Review Specialist",
      "model": "dynamic",
      "routing": "cost-optimized"
    }
  ],
  "defaults": {
    "timeout": 30000,
    "retries": 3,
    "fallback": "gemini-2.5-flash"
  }
}

interface TaskComplexityResult {
  tier: 1 | 2 | 3;
  score: number;
  reasoning: string;
  selectedModel: string;
  estimatedCost: number;
}
 
async function scoreTaskComplexity(
  task: string,
  codeContext?: string
): Promise<TaskComplexityResult> {
  const ruleBasedScore = calculateRuleBasedScore(task, codeContext);
 
  // Only invoke the local LLM when rule-based confidence is low
  if (ruleBasedScore.confidence < 0.8) {
    const llmScore = await ollamaClient.chat({
      model: LOCAL_MODEL,
      messages: [
        {
          role: "system",
          content: `You are a coding task complexity assessor.
Score tasks 1–10 using these criteria:
1–3: Boilerplate, comments, simple formatting
4–6: Algorithm implementation, API integration, moderate logic
7–10: Architecture decisions, security audits, complex business logic
Respond with JSON only: {"score": N, "reasoning": "brief reason"}`,
        },
        {
          role: "user",
          content: `Task: ${task}\n${codeContext ? `Context: ${codeContext.slice(0, 500)}` : ""}`,
        },
      ],
      format: "json",
    });
 
    try {
      const parsed = JSON.parse(llmScore.message.content);
      return mapScoreToTier(parsed.score, parsed.reasoning);
    } catch {
      return { tier: 2, score: 5, reasoning: "parse_failed", selectedModel: LOCAL_MODEL, estimatedCost: 0 };
    }
  }
 
  return mapScoreToTier(ruleBasedScore.score, ruleBasedScore.reasoning);
}
 
function calculateRuleBasedScore(
  task: string,
  codeContext?: string
): { score: number; confidence: number; reasoning: string } {
  const lowKeywords = ["comment", "format", "rename", "indent", "typo", "whitespace"];
  const highKeywords = ["security", "architecture", "vulnerability", "performance", "database migration"];
 
  const t = task.toLowerCase();
  if (lowKeywords.some((k) => t.includes(k))) return { score: 2, confidence: 0.95, reasoning: "low_keywords" };
  if (highKeywords.some((k) => t.includes(k))) return { score: 8, confidence: 0.90, reasoning: "high_keywords" };
 
  const codeLength = codeContext?.length ?? 0;
  if (codeLength > 5000) return { score: 6, confidence: 0.75, reasoning: "large_context" };
 
  return { score: 4, confidence: 0.6, reasoning: "default_medium" };
}
 
function mapScoreToTier(score: number, reasoning: string): TaskComplexityResult {
  if (score <= 3) return { tier: 1, score, reasoning, selectedModel: LOCAL_MODEL, estimatedCost: 0 };
  if (score <= 6) return { tier: 2, score, reasoning, selectedModel: LOCAL_MODEL, estimatedCost: 0 };
  return { tier: 3, score, reasoning, selectedModel: CLOUD_MODEL, estimatedCost: estimateGeminiCost(score) };
}
 
function estimateGeminiCost(score: number): number {
  // Gemini 2.5 Flash: $0.075/1M input tokens, $0.30/1M output tokens
  const inputTokens = score * 1000;
  const outputTokens = score * 500;
  return (inputTokens * 0.075 + outputTokens * 0.30) / 1_000_000;
}

interface AgentExecutionResult {
  success: boolean;
  output: string;
  model: string;
  executionTime: number;
  cost: number;
  retries: number;
  error?: string;
}
 
class HybridMultiAgentOrchestrator {
  private maxRetries = 3;
  private retryDelay = 1000;
  private costTracker = new CostTracker();
 
  async executeTask(task: string, codeContext?: string): Promise<AgentExecutionResult> {
    const startTime = Date.now();
    let retries = 0;
    let lastError: Error | null = null;
 
    const complexity = await scoreTaskComplexity(task, codeContext);
    console.log(`[Orchestrator] Tier ${complexity.tier} — model: ${complexity.selectedModel}`);
 
    while (retries < this.maxRetries) {
      try {
        const output = await this.executeWithModel(task, codeContext, complexity.selectedModel, complexity.tier);
 
        // Tier 2 must pass validation before returning
        if (complexity.tier === 2) {
          const validation = await this.validateOutput(output, task);
          if (\!validation.isValid) {
            console.warn(`[Orchestrator] Validation failed (${validation.reason}), escalating to cloud`);
            const fallback = await this.executeWithModel(task, codeContext, CLOUD_MODEL, 3);
            return this.buildResult(fallback, CLOUD_MODEL, startTime, retries, complexity.estimatedCost * 2);
          }
        }
 
        this.costTracker.record(complexity.selectedModel, complexity.estimatedCost);
        return this.buildResult(output, complexity.selectedModel, startTime, retries, complexity.estimatedCost);
 
      } catch (error) {
        lastError = error as Error;
        retries++;
 
        if (retries < this.maxRetries) {
          // If local Ollama is unreachable, fall back to cloud immediately
          if (lastError.message.includes("ECONNREFUSED") || lastError.message.includes("timeout")) {
            console.warn(`[Orchestrator] Local unavailable, switching to cloud`);
            complexity.selectedModel = CLOUD_MODEL;
          }
          await this.sleep(this.retryDelay * retries);
        }
      }
    }
 
    return {
      success: false, output: "", model: complexity.selectedModel,
      executionTime: Date.now() - startTime, cost: 0, retries,
      error: lastError?.message ?? "Max retries exceeded",
    };
  }
 
  private async executeWithModel(
    task: string, codeContext: string | undefined,
    model: string, tier: number
  ): Promise<string> {
    const systemPrompt = tier === 3
      ? "You are a senior software engineer. Provide thorough analysis covering architecture, security, and performance."
      : "You are a software engineer. Provide clear, correct code with concise explanations.";
 
    const userMessage = codeContext ? `${task}\n\n\`\`\`\n${codeContext}\n\`\`\`` : task;
 
    if (model === LOCAL_MODEL) {
      const res = await ollamaClient.chat({
        model: LOCAL_MODEL,
        messages: [{ role: "system", content: systemPrompt }, { role: "user", content: userMessage }],
        options: { temperature: 0.2, num_predict: 2048 },
      });
      return res.message.content;
    }
 
    const genModel = geminiClient.getGenerativeModel({ model });
    const chat = genModel.startChat({ history: [{ role: "user", parts: [{ text: systemPrompt }] }] });
    const result = await chat.sendMessage(userMessage);
    return result.response.text();
  }
 
  private async validateOutput(output: string, task: string): Promise<{ isValid: boolean; reason: string }> {
    const hasCode = output.includes("```");
    const expressesFailure = /\b(sorry|cannot|i'm unable)\b/i.test(output);
    if (\!hasCode && /\bcode\b/i.test(task)) return { isValid: false, reason: "no_code_block" };
    if (expressesFailure) return { isValid: false, reason: "model_expressed_failure" };
    return { isValid: true, reason: "passed" };
  }
 
  private buildResult(output: string, model: string, startTime: number, retries: number, cost: number): AgentExecutionResult {
    return { success: true, output, model, executionTime: Date.now() - startTime, cost, retries };
  }
 
  private sleep(ms: number) { return new Promise((r) => setTimeout(r, ms)); }
}

// ❌ Wrong: assuming the model remembers step 1
const step2 = await agent.run("Refactor based on the review above");
 
// ✅ Correct: inject step 1's output explicitly
const step2 = await agent.run(`
Refactor the following code based on this review:
 
Review:
${step1.output}
 
Code:
\`\`\`typescript
${originalCode}
\`\`\`
`);

// ❌ Brittle: code inside JSON breaks frequently
const res = await ollamaClient.chat({ model: LOCAL_MODEL, format: "json",
  messages: [{ role: "user", content: "Return code and explanation as JSON" }] });
 
// ✅ Reliable: use delimiters to separate code from metadata
const res = await ollamaClient.chat({ model: LOCAL_MODEL,
  messages: [{ role: "user", content: `Reply in this format exactly:
---META---
{"success": true, "language": "typescript"}
---META---
---CODE---
// your code here
---CODE---` }] });
 
function parseDelimited(raw: string) {
  const meta = raw.match(/---META---([\s\S]*?)---META---/)?.[1]?.trim();
  const code = raw.match(/---CODE---([\s\S]*?)---CODE---/)?.[1]?.trim();
  return { metadata: meta ? JSON.parse(meta) : {}, code: code ?? raw };
}

const agent = new Agent({
  model: LOCAL_MODEL,
  endpoint: "[localhost:11434](http://localhost:11434)",
  timeout: 120_000, // 2 minutes for local inference
  retryConfig: { maxRetries: 2, retryDelay: 2000, retryableErrors: ["ETIMEDOUT", "ECONNRESET"] },
});

import Semaphore from "semaphore-async-await";
const localSemaphore = new Semaphore(2); // Match OLLAMA_NUM_PARALLEL
 
async function runLocal<T>(fn: () => Promise<T>): Promise<T> {
  await localSemaphore.acquire();
  try { return await fn(); }
  finally { localSemaphore.release(); }
}
 
// Controlled parallelism
const [review, docs, tests] = await Promise.all([
  runLocal(() => reviewAgent.run(code)),
  runLocal(() => docsAgent.run(code)),
  runLocal(() => testAgent.run(code)),
]);

// ❌ Infinite recursion risk
async function run(model: string, task: string): Promise<string> {
  try { return await callModel(model, task); }
  catch { return run(model === LOCAL_MODEL ? CLOUD_MODEL : LOCAL_MODEL, task); }
}
 
// ✅ Depth-limited fallback
async function run(model: string, task: string, depth = 0): Promise<string> {
  if (depth >= 2) throw new Error("Fallback depth limit reached");
  try { return await callModel(model, task); }
  catch {
    if (depth === 0) {
      const alt = model === LOCAL_MODEL ? CLOUD_MODEL : LOCAL_MODEL;
      return run(alt, task, depth + 1);
    }
    throw new Error(`Both models failed`);
  }
}

import Fastify from "fastify";
 
const app = Fastify({ logger: true });
const tracker = new CostTracker();
 
app.get("/api/cost/summary", async () => {
  const summary = tracker.getMonthlySummary();
  const daysElapsed = new Date().getDate();
  const projected = summary.totalCost * (30 / daysElapsed);
  const allCloudEstimate = (summary.localTasks + summary.cloudTasks) * 0.002;
 
  return {
    actualCost: `$${summary.totalCost.toFixed(4)}`,
    projectedMonthly: `$${projected.toFixed(2)}`,
    estimatedSavings: `$${(allCloudEstimate - summary.totalCost).toFixed(2)}`,
    localRatio: `${(summary.localRatio * 100).toFixed(1)}%`,
    localTasks: summary.localTasks,
    cloudTasks: summary.cloudTasks,
    recommendation: summary.localRatio < 0.6
      ? "Local ratio too low. Consider raising Tier 3 threshold from score 7 to 8."
      : summary.localRatio > 0.92
      ? "Cloud usage extremely low — verify Tier 3 routing is functioning."
      : "Routing is well-balanced.",
  };
});

FROM node:22-slim AS base
RUN apt-get update && apt-get install -y curl && \
    curl -fsSL [ollama.com](https://ollama.com/install.sh) | sh
 
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY dist/ .antigravity/ ./
 
RUN ollama pull gemma4:8b || echo "Will retry at runtime"
 
HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
  CMD curl -f [localhost:11434](http://localhost:11434/api/tags) && curl -f [localhost:3000](http://localhost:3000/health) || exit 1
 
COPY scripts/entrypoint.sh ./
RUN chmod +x entrypoint.sh
EXPOSE 3000 11434
CMD ["./entrypoint.sh"]

#\!/bin/bash
# entrypoint.sh — starts Ollama then the app, handles graceful shutdown
 
ollama serve &
OLLAMA_PID=$\!
 
for i in $(seq 1 12); do
  curl -sf [localhost:11434](http://localhost:11434/api/tags) > /dev/null 2>&1 && { echo "✅ Ollama ready"; break; }
  echo "⏳ Waiting for Ollama ($i/12)..."; sleep 5
done
 
ollama list | grep -q "gemma4:8b" || { ollama pull gemma4:8b || { echo "❌ Pull failed"; exit 1; }; }
 
node dist/index.js &
APP_PID=$\!
 
trap "kill $OLLAMA_PID $APP_PID 2>/dev/null; exit 0" SIGTERM SIGINT
wait $APP_PID

import crypto from "crypto";
 
interface CacheEntry {
  output: string;
  model: string;
  cost: number;
  createdAt: number;
  hitCount: number;
}
 
class SemanticAgentCache {
  private store = new Map<string, CacheEntry>();
  private readonly TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 
  // Normalizes task + code fingerprint for cache keying
  private buildCacheKey(task: string, codeContext?: string): string {
    const normalized = task.trim().toLowerCase().replace(/\s+/g, " ");
    const codeHash = codeContext
      ? crypto.createHash("sha256").update(codeContext).digest("hex").slice(0, 16)
      : "nocode";
    return `${codeHash}:${crypto.createHash("md5").update(normalized).digest("hex")}`;
  }
 
  get(task: string, codeContext?: string): CacheEntry | null {
    const key = this.buildCacheKey(task, codeContext);
    const entry = this.store.get(key);
    if (\!entry) return null;
 
    // Evict stale entries
    if (Date.now() - entry.createdAt > this.TTL_MS) {
      this.store.delete(key);
      return null;
    }
 
    entry.hitCount++;
    return entry;
  }
 
  set(task: string, codeContext: string | undefined, result: AgentExecutionResult): void {
    if (\!result.success) return; // Don't cache failures
 
    const key = this.buildCacheKey(task, codeContext);
    this.store.set(key, {
      output: result.output,
      model: result.model,
      cost: result.cost,
      createdAt: Date.now(),
      hitCount: 0,
    });
  }
 
  getStats() {
    const entries = Array.from(this.store.values());
    const totalHits = entries.reduce((s, e) => s + e.hitCount, 0);
    const savedCost = entries
      .filter((e) => e.model \!== LOCAL_MODEL)
      .reduce((s, e) => s + e.cost * e.hitCount, 0);
    return { totalEntries: entries.size, totalHits, estimatedSavedCost: `$${savedCost.toFixed(4)}` };
  }
}
 
// Integrate the cache into the orchestrator
class HybridOrchestratorWithCache extends HybridMultiAgentOrchestrator {
  private cache = new SemanticAgentCache();
 
  async executeTask(task: string, codeContext?: string): Promise<AgentExecutionResult> {
    // Check cache first
    const cached = this.cache.get(task, codeContext);
    if (cached) {
      console.log(`[Cache HIT] model: ${cached.model}, hits: ${cached.hitCount}`);
      return { success: true, output: cached.output, model: cached.model,
               executionTime: 0, cost: 0, retries: 0 };
    }
 
    // Execute normally
    const result = await super.executeTask(task, codeContext);
 
    // Cache successful results
    if (result.success) {
      this.cache.set(task, codeContext, result);
    }
 
    return result;
  }
}

interface QualityScore {
  score: number; // 0.0 - 1.0
  dimensions: {
    hasCode: boolean;
    codeBlockCount: number;
    responseLength: number;
    containsExplanation: boolean;
    noHallucinations: boolean; // heuristic
  };
}
 
function scoreOutputQuality(output: string, task: string): QualityScore {
  const codeBlocks = (output.match(/```[\s\S]*?```/g) ?? []);
  const isCodeTask = /\b(implement|write|create|refactor|fix|generate)\b/i.test(task);
  const hasExplanation = output.length > 200 && \!/^```/.test(output.trim());
  
  // Hallucination heuristics: model expressing uncertainty in an unusual way
  const hallucinationSignals = [
    /as an ai language model/i,
    /i don't have access to/i,
    /i cannot actually run/i,
    /in a real implementation you would/i,
  ];
  const noHallucinations = \!hallucinationSignals.some((r) => r.test(output));
 
  const dimensions = {
    hasCode: codeBlocks.length > 0,
    codeBlockCount: codeBlocks.length,
    responseLength: output.length,
    containsExplanation: hasExplanation,
    noHallucinations,
  };
 
  let score = 0.5;
  if (isCodeTask && dimensions.hasCode) score += 0.2;
  if (dimensions.containsExplanation) score += 0.1;
  if (dimensions.noHallucinations) score += 0.15;
  if (dimensions.responseLength > 300) score += 0.05;
 
  return { score: Math.min(1.0, score), dimensions };
}
 
// Track quality by model and tier over time
class QualityTracker {
  private records: Array<{
    model: string; tier: number; score: number; timestamp: number;
  }> = [];
 
  record(model: string, tier: number, quality: QualityScore) {
    this.records.push({ model, tier, score: quality.score, timestamp: Date.now() });
  }
 
  getAverageByModel(windowDays = 7): Record<string, number> {
    const cutoff = Date.now() - windowDays * 86_400_000;
    const recent = this.records.filter((r) => r.timestamp > cutoff);
    const grouped: Record<string, number[]> = {};
    for (const r of recent) {
      if (\!grouped[r.model]) grouped[r.model] = [];
      grouped[r.model].push(r.score);
    }
    const result: Record<string, number> = {};
    for (const [model, scores] of Object.entries(grouped)) {
      result[model] = scores.reduce((a, b) => a + b, 0) / scores.length;
    }
    return result;
  }
 
  // Alert if local model quality drops below threshold
  shouldEscalateThreshold(): boolean {
    const averages = this.getAverageByModel(3); // last 3 days
    const localAvg = averages[LOCAL_MODEL] ?? 1.0;
    return localAvg < 0.65; // escalate if local quality drops significantly
  }
}

// Agent status endpoint for Antigravity Manager Surface integration
app.get("/api/agent-status", async () => {
  const costSummary = costTracker.getMonthlySummary();
  const qualityAvg = qualityTracker.getAverageByModel(7);
 
  return {
    status: "healthy",
    agents: [
      {
        id: "router",
        type: "router",
        model: LOCAL_MODEL,
        status: await checkOllamaHealth() ? "online" : "degraded",
      },
      {
        id: "code-reviewer",
        type: "specialist",
        model: "dynamic",
        localRatio: costSummary.localRatio,
        qualityScore: qualityAvg[LOCAL_MODEL] ?? null,
      },
    ],
    costs: {
      thisMonth: `$${costSummary.totalCost.toFixed(2)}`,
      localRatio: `${(costSummary.localRatio * 100).toFixed(1)}%`,
    },
    cacheStats: agentCache.getStats(),
  };
});
 
async function checkOllamaHealth(): Promise<boolean> {
  try {
    const res = await fetch("http://localhost:11434/api/tags", { signal: AbortSignal.timeout(3000) });
    return res.ok;
  } catch {
    return false;
  }
}

const CODE_MODEL = "codegemma:7b"; // hypothetical fine-tuned local model
const GENERAL_MODEL = LOCAL_MODEL;   // gemma4:8b
const CLOUD_MODEL = "gemini-2.5-flash";
 
function selectModel(tier: 1 | 2 | 3, taskType: "code" | "docs" | "analysis"): string {
  if (tier === 3) return CLOUD_MODEL;
  if (tier === 2 && taskType === "code") return CODE_MODEL;
  return GENERAL_MODEL;
}