A Three-Layer AI Cost Design for Rork Apps After Apple Opened Foundation Models to Small Developers

// ai-cost-simulation.ts — estimate the monthly effect of going three-layer
// run: npx tsx ai-cost-simulation.ts
 
type Layer = "on-device" | "pcc" | "third-party";
 
interface TaskProfile {
  name: string;
  monthlyCalls: number;    // calls per month
  avgInputTokens: number;  // input tokens per call
  avgOutputTokens: number; // output tokens per call
  layer: Layer;            // placement in the three-layer design
}
 
// Placeholder prices — replace with the current rates of the model you use
const THIRD_PARTY_PRICE = {
  inputPerMTok: 3.0,   // USD per million input tokens
  outputPerMTok: 15.0, // USD per million output tokens
};
 
const tasks: TaskProfile[] = [
  { name: "image tag candidates",   monthlyCalls: 120_000, avgInputTokens: 200,   avgOutputTokens: 20,  layer: "on-device" },
  { name: "review reply drafts",    monthlyCalls: 90_000,  avgInputTokens: 1_200, avgOutputTokens: 200, layer: "pcc" },
  { name: "long document analysis", monthlyCalls: 6_000,   avgInputTokens: 6_000, avgOutputTokens: 800, layer: "third-party" },
];
 
function thirdPartyCost(t: TaskProfile): number {
  const input  = (t.monthlyCalls * t.avgInputTokens)  / 1_000_000 * THIRD_PARTY_PRICE.inputPerMTok;
  const output = (t.monthlyCalls * t.avgOutputTokens) / 1_000_000 * THIRD_PARTY_PRICE.outputPerMTok;
  return input + output;
}
 
// every task on third-party APIs
const allThirdParty = tasks.reduce((sum, t) => sum + thirdPartyCost(t), 0);
 
// three-layer: on-device and pcc cost nothing (within the free tier)
const threeLayer = tasks
  .filter((t) => t.layer === "third-party")
  .reduce((sum, t) => sum + thirdPartyCost(t), 0);
 
console.log(`all third-party: $${allThirdParty.toFixed(2)} / month`);
console.log(`three-layer:     $${threeLayer.toFixed(2)} / month`);
console.log(`reduction:       ${((1 - threeLayer / allThirdParty) * 100).toFixed(1)}%`);
 
// expected output:
// all third-party: $882.00 / month
// three-layer:     $180.00 / month
// reduction:       79.6%

// AIRouter.swift — concentrate layer selection in one place
import FoundationModels
 
enum AILayer {
    case onDevice      // layer 1: in-device, free, works offline
    case privateCloud  // layer 2: Foundation Models on PCC (free tier)
    case thirdParty    // layer 3: metered APIs such as Claude / Gemini
}
 
struct AITask {
    let prompt: String
    let needsOffline: Bool
    let estimatedTokens: Int
    let qualityCritical: Bool
}
 
enum AIRouter {
    static func layer(for task: AITask) -> AILayer {
        // offline requirements force layer 1
        if task.needsOffline { return .onDevice }
        // only revenue-critical quality goes to metered layer 3
        if task.qualityCritical { return .thirdParty }
        // beyond ~4K tokens it will not fit on-device
        if task.estimatedTokens > 3_500 { return .privateCloud }
        return .onDevice
    }
 
    static func respond(to task: AITask) async throws -> String {
        switch layer(for: task) {
        case .onDevice:
            // always check device support (fall back to PCC if unsupported)
            guard case .available = SystemLanguageModel.default.availability else {
                return try await respondViaPrivateCloud(task)
            }
            let session = LanguageModelSession(
                instructions: "Answer briefly and calmly."
            )
            let response = try await session.respond(to: task.prompt)
            return response.content
        case .privateCloud:
            return try await respondViaPrivateCloud(task)
        case .thirdParty:
            return try await respondViaBackend(task) // through your own backend
        }
    }
 
    private static func respondViaPrivateCloud(_ task: AITask) async throws -> String {
        // Confirm the finalized PCC selection API in the release docs,
        // then replace only the body of this function (callers stay untouched).
        let session = LanguageModelSession(
            instructions: "Answer in short paragraphs without bullet lists."
        )
        let response = try await session.respond(to: task.prompt)
        return response.content
    }
 
    private static func respondViaBackend(_ task: AITask) async throws -> String {
        var request = URLRequest(url: URL(string: "https://api.example.com/ai/heavy")!)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = try JSONEncoder().encode(["prompt": task.prompt])
        let (data, _) = try await URLSession.shared.data(for: request)
        struct Reply: Decodable { let text: String }
        return try JSONDecoder().decode(Reply.self, from: data).text
    }
}

// expo-module.config.json — module declaration
{
  "platforms": ["apple"],
  "apple": {
    "modules": ["FoundationModelsBridgeModule"]
  }
}

// ios/FoundationModelsBridgeModule.swift — the Swift side of the bridge
import ExpoModulesCore
import FoundationModels
 
public class FoundationModelsBridgeModule: Module {
  public func definition() -> ModuleDefinition {
    Name("FoundationModelsBridge")
 
    AsyncFunction("isAvailable") { () -> Bool in
      if case .available = SystemLanguageModel.default.availability {
        return true
      }
      return false
    }
 
    AsyncFunction("respond") { (prompt: String) -> String in
      let session = LanguageModelSession(
        instructions: "Reply briefly and politely."
      )
      let response = try await session.respond(to: prompt)
      return response.content
    }
  }
}

// lib/foundation-models.ts — the JavaScript call site
import { requireNativeModule } from "expo-modules-core";
 
const FoundationModelsBridge = requireNativeModule("FoundationModelsBridge");
 
export async function localSummarize(text: string): Promise<string | null> {
  const available: boolean = await FoundationModelsBridge.isAvailable();
  if (!available) return null; // caller falls back to layer 2 or 3
  return FoundationModelsBridge.respond(`Summarize this text in three lines: ${text}`);
}

// server/ai-router.ts — put a monthly budget cap at the layer-3 entrance
import { Hono } from "hono";
 
type Bindings = {
  ANTHROPIC_API_KEY: string; // injected as an environment variable, never hard-coded
  AI_SPEND: KVNamespace;     // KV namespace holding the month-to-date spend
};
 
const MONTHLY_BUDGET_USD = 50;
 
const app = new Hono<{ Bindings: Bindings }>();
 
app.post("/ai/heavy", async (c) => {
  const { prompt, estimatedCostUsd } = await c.req.json<{
    prompt: string;
    estimatedCostUsd: number;
  }>();
 
  const monthKey = `spend:${new Date().toISOString().slice(0, 7)}`;
  const spent = Number((await c.env.AI_SPEND.get(monthKey)) ?? "0");
 
  if (spent + estimatedCostUsd > MONTHLY_BUDGET_USD) {
    // over budget: return 429 so the client retreats to layer 2 or 1
    return c.json({ fallback: true, reason: "budget_exceeded" }, 429);
  }
 
  const res = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "x-api-key": c.env.ANTHROPIC_API_KEY,
      "anthropic-version": "2023-06-01",
    },
    body: JSON.stringify({
      model: "claude-haiku-4-5-20251001",
      max_tokens: 1024,
      messages: [{ role: "user", content: prompt }],
    }),
  });
  const data = (await res.json()) as { content: { text: string }[] };
 
  await c.env.AI_SPEND.put(monthKey, String(spent + estimatedCostUsd));
  return c.json({ text: data.content[0].text });
});
 
export default app;