200 Zeilen TypeScript: Wie ein selbstgebauter KI-Router 41 % Kosten sparte

Die Nutzung von KI-Tools wie Cursor oder Copilot bietet Komfort, doch die versteckten Kosten summieren sich schnell. Ein Entwickler aus den USA dokumentierte seine monatlichen Ausgaben und erkannte, dass nicht die teuren API-Aufrufe, sondern die Abonnements für Cursor, Copilot und Anthropic die größte Belastung darstellten. Der Grund: Doppelte Abrechnung desselben Kontexts durch Wrapper, die eigene Backends nutzen, während gleichzeitig direkt auf Anthropic zugegriffen wurde.

Nach der Analyse seiner Ausgaben im März entschied sich der Entwickler zu handeln. Sein Ziel: Die Kontrolle über die Modellauswahl zurückgewinnen und die Kosten durch präzise Routing-Regeln senken. Das Ergebnis war ein 200 Zeilen umfassender TypeScript-Router, der im April 41 % weniger Kosten verursachte – bei gleichem Arbeitsvolumen.

Warum Wrapper-Nutzung teuer wird

KI-Wrapper wie Cursor oder Copilot vereinfachen die Arbeit, indem sie automatisch das passende Modell auswählen und den Kontext vorbereiten. Doch diese Bequemlichkeit hat ihren Preis:

• Versteckte Kontextkosten: Wrapper senden zusätzliche Tokens, die nicht direkt sichtbar sind. Bei einer Analyse von Cursor wurde festgestellt, dass durchschnittlich 8.400 Eingabetokens pro Chat-Nachricht an das Backend gesendet wurden – davon nur 1.900 Tokens, die direkt vom Nutzer stammten. Die Differenz von 6.500 Tokens setzt sich aus Systemprompts, Indexierungskontext und Agenten-Scaffolding zusammen.

• Modellauswahl ohne Transparenz: Wrapper wählen oft das teuerste Modell, das ihre Leistungsgarantien erfüllt, um die Demo-Erfahrung zu optimieren. Dies führt zu unnötig hohen Kosten für einfache Aufgaben, die auch mit günstigeren Modellen hätten erledigt werden können.

• Doppelte Abrechnung: Viele Nutzer greifen direkt auf Anbieter-APIs zu, während gleichzeitig Wrapper genutzt werden. Die Wrapper berechnen nicht nur ihre eigenen Dienstleistungen, sondern auch die Kosten für die genutzten Modelle – obwohl diese bereits separat abgerechnet werden.

Der selbstgebaute Router im Detail

Der Entwickler entschloss sich, einen eigenen Router zu bauen, der die Modellauswahl basierend auf dem tatsächlichen Bedarf steuert. Der Router besteht aus weniger als 200 Zeilen Code und ermöglicht eine präzise Steuerung der Kosten durch:

• Intent-basiertes Routing: Jede Anfrage wird anhand von Regeln einem bestimmten KI-Modell zugeordnet. Beispielsweise werden einfache Fragen oder Korrekturen an günstigere Modelle wie Haiku weitergeleitet, während komplexe Planungsaufgaben an teurere Modelle wie Opus gehen.

• Kostentransparenz: Der Router berechnet die genauen Kosten pro Anfrage und gibt diese direkt zurück – inklusive der genutzten Tokens und des berechneten Preises.

• Flexible Anpassung: Die Routing-Regeln können jederzeit erweitert oder angepasst werden, um spezifische Anforderungen zu erfüllen.

Hier ein Ausschnitt des Routers:

// router.ts
import Anthropic from "@anthropic-ai/sdk";
import OpenAI from "openai";

type Intent = "trivial" | "code" | "plan" | "embed";

interface RouteRule {
  match: (prompt: string) => boolean;
  intent: Intent;
}

interface ModelConfig {
  provider: "anthropic" | "openai";
  model: string;
  maxTokens: number;
}

const ROUTES: Record<Intent, ModelConfig> = {
  trivial: {
    provider: "anthropic",
    model: "claude-haiku-4-5-20251001",
    maxTokens: 1024,
  },
  code: {
    provider: "anthropic",
    model: "claude-sonnet-4-6",
    maxTokens: 4096,
  },
  plan: {
    provider: "anthropic",
    model: "claude-opus-4-7",
    maxTokens: 8192,
  },
  embed: {
    provider: "openai",
    model: "gpt-5-mini",
    maxTokens: 512,
  },
};

const RULES: RouteRule[] = [
  {
    intent: "trivial",
    match: (p) => p.length < 200 && /\?$/.test(p.trim()),
  },
  {
    intent: "trivial",
    match: (p) => /^(what is|define|fix typo|rename)/i.test(p),
  },
  {
    intent: "plan",
    match: (p) => /(refactor|design|architect|migrate|plan)/i.test(p),
  },
  {
    intent: "code",
    match: (p) => /(```|function |class |const |let )/i.test(p),
  },
  {
    intent: "embed",
    match: (p) => p.startsWith("CLASSIFY:"),
  },
];

function pickIntent(prompt: string): Intent {
  for (const rule of RULES) {
    if (rule.match(prompt)) return rule.intent;
  }
  return "code";
}

// Beispielaufruf
const out = await route("rename this function from getUser to fetchUser");
console.log(out.model, out.costUsd.toFixed(5));
// Ausgabe: claude-haiku-4-5-20251001 0.00012

Routing-Regeln, die wirklich funktionieren

Die Effektivität des Routers hängt von gut durchdachten Routing-Regeln ab. Der Entwickler setzte auf einfache, aber präzise Kriterien:

• Einfache Anfragen: Kurze Fragen oder Korrekturen werden an Haiku weitergeleitet, das für 0,80 $ pro 1 Million Eingabetokens und 4,00 $ pro 1 Million Ausgabetokens angeboten wird.

• Code-Analyse und Refactoring: Komplexere Code-Fragen oder Refactoring-Aufgaben werden an Sonnet delegiert, das zwar teurer ist, aber bessere Ergebnisse liefert.

• Planung und Architektur: Aufgaben, die mehrstufige Planung erfordern, werden an Opus weitergeleitet, das zwar die höchsten Kosten verursacht, aber die beste Leistung bietet.

• Embeddings und Klassifizierung: Für vorbereitende Aufgaben wie Embeddings oder Klassifizierung wird GPT-5-mini genutzt, das besonders günstig ist.

Der Router ist bewusst einfach gehalten, um Wartbarkeit und Erweiterbarkeit zu gewährleisten. Für spezielle Fälle können zusätzliche Regeln hinzugefügt oder bestehende angepasst werden. Beispielsweise lässt sich durch einen Prefix wie [force:opus] eine bestimmte Anfrage explizit an ein bestimmtes Modell weiterleiten.

Fazit: Kostenkontrolle durch Eigeninitiative

Die Erfahrung des Entwicklers zeigt, dass die Nutzung von KI-Tools nicht zwangsläufig teuer sein muss. Durch den Einsatz eines selbstgebauten Routers konnten die Kosten um 41 % gesenkt werden – bei gleichbleibender Qualität und Flexibilität. Der Router bietet nicht nur finanzielle Vorteile, sondern auch volle Kontrolle über die genutzten Modelle und die Abrechnung.

Für Entwickler, die regelmäßig mit KI-Tools arbeiten, lohnt es sich, die eigenen Ausgaben zu analysieren und gegebenenfalls eigene Routing-Lösungen zu implementieren. Die Investition in einige hundert Zeilen Code kann sich schnell amortisieren und langfristig erhebliche Einsparungen bringen.