KI-Arten im Überblick – Architektur & Modellauswahl

Du willst in deiner Web-App Belege auslesen oder Kundentexte analysieren und bindest aus Gewohnheit das größte, teuerste Frontier-Modell ein. Nach dem Launch explodieren die Monatsrechnungen, Nutzer warten frustriert fünf Sekunden auf jede Antwort, und bei einfachen Rechnungen halluziniert das System falsche Zahlen. Das „Hammer-Nagel-Problem“ vernichtet Marge und Nutzervertrauen.

Moderne Softwarearchitektur trennt Aufgaben in spezialisierte Modellklassen statt eines monolithischen Alleskönners: Schnelle Small Language Models (SLMs) (Kompakte Sprachmodelle mit 1 bis 8 Milliarden Parametern, optimiert für spezifische Aufgaben bei minimaler Latenz und geringen Kosten.) und Worker-Modelle für strukturierte JSON-Extraktion, spezialisierte Reasoning-Modelle für tiefe Logik, lokale Edge-Inferenz für Datenschutz und deterministische ML-Algorithmen (wie XGBoost) für tabellarische Daten. Die Auswahl steuern drei harte Faktoren: Inferenz-Latenz, Token-Kosten und deterministische Verlässlichkeit.

Wie unterscheidet sich die moderne KI-Landschaft?

Die Vorstellung eines einzelnen Universalmodells für alle Anwendungsfälle ist in der Praxis überholt. Moderne Produktionsarchitekturen unterscheiden fünf grundlegende Säulen, die jeweils eigene Stärken, Latenzprofile und Kostenstrukturen aufweisen:

1. Frontier- & Reasoning-Flaggschiffe (z. B. Claude Fable 5 / Mythos 5, DeepSeek-V4 Pro, GPT-6 Sol, Gemini 4 Argon): Diese Systeme nutzen Test-Time Compute (Zusätzliche Rechenzeit während der Inferenz, bei der das Modell vor der finalen Antwort schrittweise Denkketten (Chain-of-Thought) generiert und verifiziert.), um vor der Ausgabe eigene Denkketten zu evaluieren. Sie glänzen bei mathematischen Beweisen, tiefer Software-Architektur und komplexen AST-Analysen, erzeugen jedoch spürbare Antwortpausen von 5 bis 30 Sekunden und verursachen höhere Tokenkosten.
2. High-Throughput Worker- & Utility-LLMs (z. B. Gemini 3.8 Flash, Claude Haiku 4.5, DeepSeek-V4.1-Flash): Auf extreme Inferenzgeschwindigkeit (< 220ms) und minimale Tokenkosten ($0,08 bis $0,35 pro 1M Tokens) optimierte Allrounder. Sie sind das Arbeitstier für Zusammenfassungen, Klassifikation, Routing und strikte JSON-Extraktion im Web-Kontext.
3. Lokale On-Device- & Small Language Models (SLMs z. B. Gemma 3 2B/4B, Phi-4 Mini, Llama 4 Maverick): Modelle mit 1 bis 7 Milliarden Parametern, die direkt auf Client-Geräten (per WebNN/WebGPU) oder schlanken Server-CPUs laufen. Sie bieten 0 Dollar externe API-Kosten, funktionieren vollständig offline und garantieren 100%ige DSGVO-Datensouveränität.
4. Multimodale & Native Streaming-Modelle (z. B. Gemini 3.8 Flash Live, Cartesia Sonic 2, FLUX.1 Ultra): Speziell trainierte Architekturen für Medien. Native Voice-to-Voice-Modelle eliminieren die klassische Verzögerung separater Spracherkennung und Textsynthese (Latenz < 250ms); moderne Diffusions- und Flow-Matching-Modelle erzeugen hochauflösende Bildinhalte in Sekunden.
5. Deterministische Algorithmen & Tabular ML (z. B. XGBoost 3.0, LightGBM 4.2, Random Forest): Klassisches maschinelles Lernen auf strukturierten Datensätzen. Für Betrugserkennung (Fraud Detection), Abwanderungsprognosen (Churn) und Finanzanalysen sind sie jedem generativen LLM haushoch überlegen: Inferenz in unter 5 Millisekunden, mathematisch reproduzierbare Wahrscheinlichkeiten und null Halluzinationen.

Warum Compound AI Systems monolithische Modelle ablösen

Einer der bedeutendsten Paradigmenwechsel in der Softwareentwicklung ist der Übergang von einzelnen monolithischen LLMs hin zu Compound AI Systems (Systeme, die KI-Aufgaben durch das Zusammenspiel mehrerer spezialisierter Komponenten lösen (z.B. Router, Vektorsuche, kleine Modelle und Validierungstools), statt alles einem einzigen Riesenmodell zu überlassen.). Wie Forscher des Berkeley AI Research (BAIR) Labs um Matei Zaharia zeigten, lassen sich durch geschickte Systemarchitektur weit höhere Leistungszuwächse erzielen als durch das bloße Hochskalieren von Modellparametern.

In einem Compound AI System übernimmt nicht ein einzelnes Modell die gesamte Wertschöpfung. Stattdessen arbeitet eine Pipeline aus spezialisierten Bausteinen:

• Gateway-Router & Triage (FrugalGPT-Muster): Eingehende Prompts werden analysiert. 80 bis 90 Prozent aller Standardanfragen werden an kostengünstige Worker-Modelle geleitet. Nur die verbleibenden 10 bis 20 Prozent anspruchsvoller Aufgaben eskalieren an ein teures Reasoning-Modell. Das senkt Betriebskosten um bis zu 90 Prozent bei identischer Systemqualität.
• Deterministische Kontrollschicht: Mathematische Kalkulationen, Datumsfilter und Rechteprüfungen werden durch regulären Programmcode oder SQL ausgeführt, anstatt ein Sprachmodell raten zu lassen.
• Strikte Schema-Validierung: Modellantworten werden zur Laufzeit durch Schemavalidierer (wie Zod) geprüft. Schlägt die Validierung fehl, greift ein deterministischer Retry oder Fallback.

Wie finde ich das optimale Modell für mein Budget?

Die Auswahl des richtigen Stacks hängt von drei konkreten Parametern ab: Dem geforderten Latenz-Budget, dem monatlichen Anfragevolumen und der mathematischen Fehlertoleranz der Aufgabe.

Nutze den folgenden Kalkulator, um für dein monatliches Anfragevolumen, deine Latenzanforderung und deine Payload-Größe die reale Kostenersparnis und Latenzverbesserung gegenüber einem naiven Frontier-Monolithen zu berechnen.

1// Next.js API Route: Schlanker Worker mit Schema-Zwang
2import { GoogleGenAI, Type } from "@google/genai";
3import { InvoiceSchema } from "@/lib/schemas/invoice";
4
5const ai = new GoogleGenAI({});
6
7export async function POST(req: Request) {
8  const { documentText } = await req.json();
9
10  // Gemini 3.8 Flash: $0.08 / 1M Input Tokens, ~210ms TTFT Latenz
11  const response = await ai.models.generateContent({
12    model: "gemini-3.8-flash",
13    contents: documentText,
14    config: {
15      responseMimeType: "application/json",
16      responseSchema: {
17        type: Type.OBJECT,
18        properties: {
19          invoiceNumber: { type: Type.STRING },
20          totalAmount: { type: Type.NUMBER },
21          taxAmount: { type: Type.NUMBER },
22          items: {
23            type: Type.ARRAY,
24            items: { type: Type.STRING },
25          },
26        },
27        required: ["invoiceNumber", "totalAmount"],
28      },
29    },
30  });
31
32  const parsed = InvoiceSchema.parse(JSON.parse(response.text!));
33  return Response.json(parsed);
34}

Die im Kalkulator sichtbare Ersparnis von über 98 Prozent bei strukturierten Extraktionen basiert auf realen Marktpreisen moderner Worker-Modelle (Stand 2026: 0,08 Dollar Input / 0,30 Dollar Output pro 1 Million Tokens bei Gemini 3.8 Flash) im Vergleich zu klassischen Frontier-Flaggschiffen wie GPT-6 Sol oder Claude Opus 5.5 (3,00 Dollar / 15,00 Dollar). Das Experiment zeigt jedoch auch die Systemgrenzen: Bei hochgradig neuartigen Denkaufgaben ohne formales Schema führt an tiefem Reasoning kein Weg vorbei; hier muss das Latenzbudget in der Benutzeroberfläche durch asynchrone Statusmeldungen abgefangen werden.

Wie sieht eine produktive Router-Architektur im Code aus?

Die folgende TypeScript-Implementierung demonstriert das Herzstück eines Compound AI Systems: Ein Gateway-Router mit zweistufiger Kaskade, Latenzüberwachung und nativer Schema-Validierung.

1// app/api/smart-router/route.ts
2import { NextResponse } from "next/server";
3import { GoogleGenAI, Type } from "@google/genai";
4import { z } from "zod";
5
6const ai = new GoogleGenAI({});
7
8// Zod-Schema zur strikten Laufzeitvalidierung
9const DocumentDataSchema = z.object({
10  category: z.enum(["invoice", "support_ticket", "feedback"]),
11  confidence: z.number().min(0).max(1),
12  summary: z.string(),
13  extractedValues: z.record(z.string(), z.union([z.string(), z.number()])),
14});
15
16export async function POST(req: Request) {
17  const { userPrompt, complexityScore } = await req.json();
18
19  // 1. Kaskaden-Entscheidung (FrugalGPT Pattern)
20  // Bei Standardkomplexität (< 0.75) nutzt das System den schnellen Worker
21  if (complexityScore < 0.75) {
22    try {
23      const response = await ai.models.generateContent({
24        model: "gemini-3.8-flash", // $0.08 / 1M Tokens, ~210ms TTFT
25        contents: userPrompt,
26        config: {
27          responseMimeType: "application/json",
28          responseSchema: {
29            type: Type.OBJECT,
30            properties: {
31              category: { type: Type.STRING },
32              confidence: { type: Type.NUMBER },
33              summary: { type: Type.STRING },
34              extractedValues: { type: Type.OBJECT },
35            },
36            required: ["category", "confidence", "summary"],
37          },
38        },
39      });
40
41      const parsed = DocumentDataSchema.parse(JSON.parse(response.text!));
42      return NextResponse.json({ ...parsed, tier: "worker-fast", latency: "<220ms" });
43    } catch {
44      // Automatischer Fallback bei Schema-Misserfolg
45      console.warn("Worker-Validierung fehlgeschlagen, eskaliere an Reasoning-Modell...");
46    }
47  }
48
49  // 2. Eskalation an Reasoning-Modell nur bei hoher Komplexität oder Fallback
50  const reasoningResponse = await ai.models.generateContent({
51    model: "gemini-4-argon", // Flaggschiff mit tiefem Test-Time Compute
52    contents: `Analysiere und extrahiere unter strikter Einhaltung der Fakten: ${userPrompt}`,
53  });
54
55  return NextResponse.json({
56    raw: reasoningResponse.text,
57    tier: "reasoning-escalated",
58    latency: ">2500ms",
59  });
60}

Architektonische Entscheidungen & typische Fehlannahmen

1. Reines LLM als Datenbank- und Rechenknecht

Ein Sprachmodell „weiß“ Fakten nur probabilistisch aus seinen Trainingsgewichten und neigt bei Rechenaufgaben zu plausiblen Fehlern. Für numerische Genauigkeit ist ein Code-Interpreter oder Tabular ML Pflicht; für verlässliche Unternehmensfakten eine vorgeschaltete semantische Suche via Vektor-Embeddings.

2. Autonome Endlos-Schleifen für Standard-Prozesse

Agenten mit rekursivem Reasoning (ReAct, Chain-of-Thought) sind wertvoll bei explorativer Code-Synthese. Besteht ein Workflow jedoch aus festen linearen Schritten, ist eine deterministische State-Machine hundertmal stabiler, zehnmal schneller und verbraucht einen Bruchteil der Token.

Checkliste: Architekturentscheidung vor Produktionsstart

• Modellgröße minimiert: Ein Small Language Model (SLM) oder Worker-Modell wurde als primärer Benchmark getestet.
• Latenz-Budget eingehalten: Time-to-First-Token (TTFT) liegt im interaktiven UI-Flow unter 500 Millisekunden.
• Strukturierte Ausgaben: JSON-Validierung per Zod oder nativer Schema-Definition im Modell zwingend konfiguriert.
• Kaskaden-Routing implementiert: Teure Reasoning-Modelle werden nur nach automatischer Komplexitäts-Triage aufgerufen.
• Deterministische Trennung: Numerische Berechnungen und Tabellendaten laufen über regulären Code oder Tabular ML (XGBoost) statt generativer Prompts.

Quellen und weiterführende Kacheln

• Berkeley AI Research (BAIR): The Shift from Models to Compound AI Systems – Grundsatzanalyse über modulare KI-Systeme von Matei Zaharia, Omar Khattab et al. (2024).
• Stanford University: FrugalGPT: How to Use Large Language Models While Reducing Cost and Damage – Wissenschaftliche Arbeit zur Kaskadierung und adaptivem Modellrouting von Lingjiao Chen, Matei Zaharia und James Zou (2023).
• Google DeepMind: Gemini 3.8 Flash & Gemini 4 Architecture Reports – Technische Dokumentation über sub-250ms Inferenz und native multimodale Streaming-Verarbeitung (2026).
• Anthropic Research: Claude 5 System Architecture & Reasoning Evaluation – Modellfamilie um Claude Fable 5 und extended thinking modes (2026).

Folgende Kacheln vertiefen spezialisierte Architekturen im Digital Garden:

• Vektor-Embeddings & semantische Suche – Wie Texte in mathematische Vektoren umgewandelt werden, um Halluzinationen per RAG zu verhindern.
• WebNN – Maschinelles Lernen lokal im Browser – Wie moderne SLMs per NPU- und WebGPU-Beschleunigung ohne Serverkosten direkt auf dem Client laufen.