---
title: "LiteAgents SDK: Modell-Routing, Setup und Migration"
canonical: https://wavect.io/de/blog/liteagents-sdk-per-turn-model-routing/
language: de
description: "LiteLLMs LiteAgents SDK mit Modell-Routing pro Turn: Paket prüfen, Claude Agent SDK migrieren, Jev-Fallbacks erkennen und Kosten je akzeptierter Aufgabe bewerten."
image: "https://wavect.io/img/blog/headers/header_liteagents-sdk-per-turn-model-routing.png"
---

[**Zurück**](/de/blog/overview/)

[![Kevin Riedl](/img/team/kevin.webp)](/de/team/kevin-riedl/)

[Kevin Riedl](/de/team/kevin-riedl/) https://linkedin.com/in/wsdt

16 Min. Lesezeit · 25. Sep. 2026 Zuletzt geprüft 25. September 2026

[**Weiter**](/de/blog/jev-ai-decision-model-review/)

# LiteAgents SDK: Modell-Routing, Setup und Migration

TL;DR

LiteAgents ist BerriAIs anbieterunabhängiges Python-SDK für Agenten mit einer query()-Schnittstelle nach dem Vorbild des Claude Agent SDK. Ein zustandsbehafteter Client kann den Gesprächsverlauf behalten und Modelle wechseln. Im geprüften Quellcode speichert der Jev-Router seine Wahl pro Nutzer-Turn, statt nach jedem Werkzeugergebnis neu zu klassifizieren. Prüfe Paketidentität, Klassifikations-Endpunkt, Werkzeugberechtigungen und Fallbacks vor dem Repository-Zugriff. Entscheidend sind Kosten je akzeptierter Aufgabe, nicht nur billigere Modellaufrufe.

Ein Login-Fehler ist keine einheitliche Aufgabe. Ursache finden, eine defensive Korrektur entwerfen, Tests prüfen und einen Pull Request erklären verlangen unterschiedliche Arbeit. Überall dasselbe große Modell einzusetzen, kann unnötig teuer sein. Alles dem billigsten Modell zu überlassen, kann noch teurer werden, sobald zusätzliche Versuche oder manuelle Korrekturen nötig sind.

**LiteAgents SDK macht die Modellwahl zu einem Bestandteil der Agenten-Laufzeit.** Dieser Leitfaden beantwortet die Umsetzungsfragen: Was bedeutet „pro Turn“? Welches Paket ist gemeint? Wie funktioniert ein eigener Router? Was macht der Jev-Fallback tatsächlich? Und was ändert sich bei einer Migration vom Claude Agent SDK?

**Quellenprüfung:** 25. September 2026. Aussagen zum Code beziehen sich auf BerriAI/liteagents, Commit `539a6e2`. Die Beispiele wurden mit den Quellen abgeglichen, sind aber kein Live-Benchmark mit Modellanbietern und kein Nachweis eines LiteAgents-Kundenprojekts von Wavect.

## Was ist LiteAgents SDK, und welche Rolle spielt LiteLLM?

LiteAgents ist BerriAIs Python-SDK für Agenten, die über eine vertraute `query()`-Schnittstelle mehrere Modellanbieter nutzen. Die [Produktseite von LiteLLM](https://www.litellm.ai/liteagents) beschreibt das Grundprinzip: Das Modell soll zur jeweiligen Arbeit passen, statt dauerhaft für den gesamten Agenten festzustehen.

Die [Ankündigung](https://www.linkedin.com/posts/reffajnaahsi_your-agent-shouldnt-use-the-same-model-for-activity-7508328914746806272-UeCq) illustriert einen Login-Fix mit Claude Opus 4.8 für die Planung, GPT-5.4 mini für Implementierung und Tests sowie Claude Sonnet 4.6 für die PR-Beschreibung. Das sind Beispielrollen, keine durch Benchmarks bewiesene Rangfolge und keine Zusage, dass ein einzelner Prompt genau diese Abfolge erzeugt.

Das [geprüfte SDK-README](https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/README.md) dokumentiert feste Modelle, eigene Router, Jev-basierte Stufenwahl, einen zustandsbehafteten Client, MCP-Werkzeugadapter und einen separaten Fusion-Modus. LiteLLM stellt die darunterliegende Modellanbindung bereit. LiteAgents ergänzt Gesprächsführung und Werkzeugschleife.

Hier geht es um die Integration dieses konkreten SDK. Für die übergeordnete Infrastrukturentscheidung gibt es unseren [Vergleich von LLM-Gateways und Routern](/de/blog/llm-gateway-router-comparison-2026/). Das Entscheidungsmodell selbst behandeln wir im [technischen Jev-Überblick](/de/blog/jev-ai-decision-model-review/). Diese Entscheidungen sollten getrennt bleiben.

## Wechselt LiteAgents nach jedem Werkzeugaufruf das Modell?

**Nicht automatisch mit dem geprüften Jev-Router.** Ein Nutzer-Turn ist etwas anderes als eine Modellaufruf-Runde. Die [Client-Implementierung](https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/src/liteagents/agent.py) erhöht den Turn-Zähler für jedes `agent.query(prompt)`. Innerhalb dieses Aufrufs können mehrere Modellantworten und Werkzeugergebnisse entstehen.

Die [Implementierung der Werkzeugschleife](https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/src/liteagents/loop.py) fragt vor jeder Modellaufruf-Runde den Router. Der [Jev-Router](https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/src/liteagents/routers/jev.py) speichert die gewählte Route jedoch unter `context.turn`. Weitere Runden desselben Nutzer-Turns verwenden diese Wahl erneut. Ein eigener Router kann den aktuellen Verlauf auswerten und anders reagieren; der eingebaute Jev-Pfad klassifiziert nicht nach jedem Werkzeugergebnis neu.

| Grenze | Geprüftes Verhalten | Folge für die Umsetzung |
| --- | --- | --- |
| Nutzer-Turn | Ein query-Aufruf beim zustandsbehafteten Client | Planung, Entwurf und Zusammenfassung bei Bedarf als getrennte Turns abbilden. |
| Modellaufruf-Runde | Eine Modellantwort, gegebenenfalls gefolgt von Werkzeugen und einer weiteren Antwort | Der Routing-Hook läuft erneut, Jev liefert aber die gespeicherte Wahl dieses Turns. |
| Fusion-Delegation | Ein Hauptagent übergibt Arbeit an einen Sidekick mit eigenem Verlauf | Getrennt vom sequenziellen Modellwechsel bewerten. |

Unterscheide außerdem Gesprächskontext und Routing-Kontext. Der Jev-Adapter übermittelt dem Klassifikator den aktuellen Prompt und die Stufenbeschreibungen, nicht den gesamten Verlauf. „Mach den nächsten Teil“ liefert ihm deshalb weniger Information als eine eigenständig verständliche Aufgabenbeschreibung. Erzeuge den Router pro Client: Sein nach Turn-Nummern organisierter Cache sollte nicht ungeprüft zwischen unabhängigen Sitzungen geteilt werden.

## Wie installierst du das richtige LiteAgents-Paket?

**Prüfe die Repository-Identität, bevor du einen Installationsbefehl übernimmst.** Die geprüften [Paketmetadaten von BerriAI](https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/pyproject.toml) nennen Python ab Version 3.10 und die Paketversion `0.1.0`. Am Prüftag zeigte der [öffentliche PyPI-Eintrag namens liteagents](https://pypi.org/project/liteagents/) dagegen ein anderes Projekt, Version `0.0.2`, aus Januar 2025. Gleiche Namen bedeuten nicht gleiche Software.

Für diese Quellenprüfung ist eine frische Umgebung mit explizitem Repository-Commit eindeutig. Die folgenden Shell-Befehle benötigen Git und eine POSIX-kompatible Shell. Ein festgelegter Commit identifiziert den installierten Code, beweist aber weder dessen Sicherheit noch die seiner Abhängigkeiten.

```
python3 -m venv .venv
source .venv/bin/activate
python -m pip install \
  "liteagents @ git+https://github.com/BerriAI/liteagents.git@539a6e2a9669433ffa9034ae262718e30c4f80b6"
python -c "from liteagents import LiteAgentOptions, LiteAgentClient; print('SDK imports OK')"
```

Die [pip-Dokumentation zur VCS-Installation](https://pip.pypa.io/en/stable/topics/vcs-support/) beschreibt direkte Referenzen auf vollständige Commit-Hashes. Prüfe bei der Einführung den aktuellen Veröffentlichungskanal des Anbieters und fixiere sowie prüfe auch die transitiven Abhängigkeiten. Verwende nicht ungeprüft eine Produktionsumgebung weiter, in der bereits ein anderes Paket gleichen Namens installiert ist.

Bei `ImportError: cannot import name 'LiteAgentOptions'` kontrolliere `python -m pip show liteagents`, den aktiven Interpreter und eine mögliche lokale Datei `liteagents.py`, die das Paket verdeckt. Ein Importfehler belegt keinen fehlerhaften API-Schlüssel des Modellanbieters.

## Wie funktioniert Modell-Routing ohne Jev?

**Implementiere eine asynchrone Methode `route(context)`, die eine freigegebene Modellkennung zurückgibt.** Wenn die Anwendung den Arbeitsschritt bereits kennt, braucht sie keinen Klassifikationsdienst. Das liefert zudem eine brauchbare Vergleichsbasis, bevor probabilistisches Routing hinzukommt.

Setze `LITEAGENTS_REASONING_MODEL`, `LITEAGENTS_FAST_MODEL` und `LITEAGENTS_BALANCED_MODEL` auf für dein Konto verfügbare Modellkennungen mit Anbieterpräfix. Hinterlege die Zugangsdaten jedes ausgewählten Modellanbieters separat. Die Bezeichnungen beschreiben Anwendungsrollen, keine garantierten Fähigkeiten.

Das vollständige Python-Beispiel behält ein Gespräch über drei explizite Turns hinweg. Es erstellt ausschließlich Textentwürfe: Repository, Shell, Test-Runner und GitHub-Veröffentlichung sind nicht angebunden. Timeout und Ausgabelimit begrenzen einzelne Aufrufe; ein produktiver Auftrag benötigt zusätzlich ein Gesamtlaufzeitlimit und eine Kostengrenze.

```
import asyncio
import os
from dataclasses import dataclass

from liteagents import (
    AssistantMessage, LiteAgentClient, LiteAgentOptions,
    TextBlock, TurnContext,
)

def required(name: str) -> str:
    value = os.environ.get(name, "").strip()
    if not value:
        raise RuntimeError(f"Set {name} to an approved provider/model ID")
    return value

@dataclass(frozen=True)
class StageRouter:
    models: tuple[str, ...]

async def route(self, context: TurnContext) -> str:
        index = context.turn - 1
        if not 0 <= index < len(self.models):
            raise RuntimeError("No approved model for this workflow stage")
        return self.models[index]

async def main() -> None:
    router = StageRouter(models=(
        required("LITEAGENTS_REASONING_MODEL"),
        required("LITEAGENTS_FAST_MODEL"),
        required("LITEAGENTS_BALANCED_MODEL"),
    ))
    options = LiteAgentOptions(
        model_router=router,
        system="Draft suggestions only. Never claim a tool or test was run.",
        max_tokens=1200,
        max_turns=4,
        model_kwargs={"timeout": 45, "num_retries": 0},
    )
    prompts = (
        "A login handler calls password.strip() before checking for None. "
        "Explain the failure and propose a defensive fix.",
        "Draft unit-test cases for that fix. Do not execute anything.",
        "Draft a PR description. Separate proposed changes from verified results.",
    )
    async with LiteAgentClient(options=options) as agent:
        for prompt in prompts:
            last = None
            async for event in agent.query(prompt):
                if isinstance(event, AssistantMessage):
                    last = event
                    print(f"model={event.model} stop={event.stop_reason}")
                    for block in event.content:
                        if isinstance(block, TextBlock):
                            print(block.text)
            if last is None or last.stop_reason not in {
                "end_turn", "stop", "stop_sequence",
            }:
                raise RuntimeError("Incomplete stage; do not continue automatically")

if __name__ == "__main__":
    asyncio.run(main())
```

Router und Client folgen der [dokumentierten Schnittstelle für eigene Router](https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/README.md). Das deterministische Beispiel bricht bei einem unerwarteten vierten Schritt bewusst ab, statt still ein Modell auszuwählen. Auch nach einer unvollständigen Antwort läuft es nicht automatisch weiter. Parallele Aufträge gehören in getrennte Clients, nicht in konkurrierende Aufrufe desselben zustandsbehafteten Clients.

## Wie wählt Jev beim automatischen Routing eine Stufe?

`JevAgent` ist die komfortable Hülle. Mit `JevModelRouter` innerhalb von `LiteAgentOptions` lässt sich Routing mit weiteren Optionen kombinieren. Definiere Modellstufen und ein Fallback-Modell. Im geprüften Adapter verwendet die Klassifikation Stufennamen und Beschreibungen; der Aufruf enthält keine aktuellen Modellpreise oder gemessenen Qualitätsscores. „Bestmöglich passend“ ist das Ziel, kein Beweis eines globalen Kostenoptimums.

Das folgende Beispiel zeigt die Konfiguration, keine verifizierte Live-Jev-Integration. Es liest `TYPESAFE_API_KEY` ausdrücklich ein, damit fehlende Konfiguration schon beim Start auffällt und nicht unbemerkt zum Fallback führt.

```
import os
from liteagents import JevModelRouter, JevTier, LiteAgentOptions

router = JevModelRouter(
    tiers=(
        JevTier(name="FAST", model=os.environ["LITEAGENTS_FAST_MODEL"],
                description="Bounded edits and test-case drafting"),
        JevTier(name="BALANCED", model=os.environ["LITEAGENTS_BALANCED_MODEL"],
                description="Routine implementation and explanations"),
        JevTier(name="REASONING", model=os.environ["LITEAGENTS_REASONING_MODEL"],
                description="Ambiguous diagnosis and architecture"),
    ),
    fallback_model=os.environ["LITEAGENTS_REASONING_MODEL"],
    api_key=os.environ["TYPESAFE_API_KEY"],
    timeout=5.0,
)
options = LiteAgentOptions(model_router=router, max_tokens=1200, max_turns=4)
```

**Prüfe zuerst den API-Vertrag.** Der [geprüfte Adapter](https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/src/liteagents/routers/jev.py) sendet an `/v1/classify` und bezeichnet diesen HTTP-Vertrag als illustrativ beziehungsweise „best-effort“. Die [öffentliche Modellreferenz von TypeSafe](https://docs.typesafe.ai/models) dokumentiert `POST /v1/systemone`. Diese Abweichung verlangt einen Live-Kompatibilitätstest oder einen korrigierten Adapter; sie beweist nicht, dass ein undokumentierter Endpunkt unmöglich existiert.

Bis diese Prüfung bestanden ist, nutze den deterministischen Router oder einen eigenen, gegen die dokumentierte Schnittstelle getesteten Adapter. Erfinde keine Konfidenzschwellen für den eingebauten Adapter: Er verarbeitet einen Stufennamen und stellt die Wahrscheinlichkeitsverteilung des Klassifikators nicht bereit.

## Warum verwendet LiteAgents immer das Fallback-Modell?

**Eine fertige Antwort beweist nicht, dass automatisches Routing funktioniert hat.** Im geprüften Jev-Code können ein fehlender Schlüssel, ein behandelter HTTP-Fehler, ungültiges JSON oder eine unbekannte Stufe zur Auswahl von `fallback_model` führen. Die Anwendung antwortet dann möglicherweise weiter, ohne die erwartete Routing-Ersparnis zu erzielen.

Prüfe Zugangsdaten, Endpunkt, Antwortschema und genaue Stufennamen. Ein instrumentierter Adapter sollte protokollieren, ob eine Route klassifiziert, durch eine feste Regel erzwungen oder nach einem Fehler gewählt wurde. Erfasse angeforderte Route, `AssistantMessage.model` und Nutzung. Derselbe Modellname kann sowohl eine reguläre Auswahl als auch ein Fallback sein; allein daran ist der Unterschied nicht erkennbar.

Verstehe Fallback nicht als universelle Fehlerbehandlung. Der geprüfte Code erwartet beispielsweise JSON mit einem Feld `tier`; ein unerwarteter oberster Datentyp muss ebenfalls getestet werden. Klassifikator-Fallback ist außerdem kein Anbieter-Failover: Nach der Modellwahl können Authentifizierung, Ratenbegrenzungen und Generierung weiterhin scheitern. [LiteLLM dokumentiert Anbieter-Failover separat](https://docs.litellm.ai/docs/proxy/reliability).

Auch das Fallback-Modell muss innerhalb derselben freigegebenen Anbieter- und Datengrenzen bleiben. „Das sichere Modell verwenden“ ist keine Berechtigungsentscheidung und darf Vorgaben zu Region, Mandant oder Vertraulichkeit nicht umgehen.

## Ist LiteAgents ein austauschbarer Ersatz für das Claude Agent SDK?

**Vertraute Schnittstelle bedeutet nicht identische Laufzeit.** Imports lassen sich möglicherweise schnell ändern. Werkzeuge, Berechtigungen, Persistenz und Ausführungsannahmen brauchen eigene Migrationsprüfungen. [Anthropics Übersicht zum Agent SDK](https://code.claude.com/docs/en/agent-sdk/overview) beschreibt eine auf Claude Code basierende Laufzeit mit eingebauten Werkzeugen, Berechtigungen, Sitzungen und Hooks.

| Bereich | Einstiegspunkt in LiteAgents | Was geprüft werden muss |
| --- | --- | --- |
| Abfrage und Client | query(), LiteAgentOptions, LiteAgentClient | Prompt-Verarbeitung, Ereignisse, Abbruchgründe und Fehlerweitergabe in der Anwendung. |
| Werkzeuge | Explizite Tool-Instanzen oder MCP-Adapter | Repository-Zugriff, Befehlsausführung und PR-Erstellung müssen tatsächlich angebunden sein. |
| Berechtigungen | Durchsetzung durch die Anwendung an den Werkzeuggrenzen | Benötigte Freigaben und Sandbox-Kontrollen vor Schreibzugriffen wiederherstellen. |
| Gesprächszustand | Zustandsbehafteter In-Memory-Client mit übergebbarem Anfangsverlauf | Dauerhafte Speicherung, Mandantentrennung, Wiederaufnahme und Kontextgrenzen. |
| Betriebliches Routing | Anbietermodelle oder Gateway-Aliase | Kompatibilität, Zugangsdaten, Budgets, Failover und zusammenhängende Traces. |

Die [geprüften LiteAgents-Optionen und der Client](https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/src/liteagents/agent.py) definieren die lokale API-Grenze. Die [MCP-Dokumentation](https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/README.md) weist Transport, Authentifizierung und Sitzungslebensdauer der Anwendung zu. Der Adapter ist kein Berechtigungssystem. Halte initialisierte MCP-Sitzungen während der Werkzeugnutzung offen und gib nur ausdrücklich erlaubte Werkzeuge frei.

Ein LiteLLM-Gateway kann unterhalb des Agenten Deployment-Auswahl und Zuverlässigkeit übernehmen. Die [LiteLLM-Router-Dokumentation](https://docs.litellm.ai/docs/routing) beschreibt diese Infrastrukturebene. Mit der Installation des Agenten-SDK sind weder automatisch ein Gateway bereitgestellt noch unternehmensweite Ausgabenlimits aktiviert.

## Wie sollte „Login-Fehler beheben, Tests ergänzen und PR öffnen“ ablaufen?

Mache die Grenzen explizit. Zuerst wird das Fehlverhalten mit einem reproduzierbaren Beispiel und lesendem Repository-Zugriff untersucht. Danach erstellt ein Implementierungsschritt eine begrenzte Änderung auf einem isolierten Branch. Ein separates Testwerkzeug muss die tatsächlichen Prüfungen ausführen und Exit-Code sowie Ausgabe zurückgeben. Eine Review-Stufe bewertet Änderung und Nachweise, bevor ein Veröffentlichungswerkzeug einen Entwurfs-PR erstellt.

Die Routing-Regel kann ein Reasoning-Modell für die Diagnose, ein kleineres Modell für eine eng begrenzte Änderung und ein ausgewogenes Modell für die Erklärung vorsehen. Diese Zuordnung ist eine zu prüfende Hypothese, keine universelle Empfehlung. Ein Authentifizierungsfehler kann sicherheitsrelevant sein, obwohl die Codeänderung klein aussieht.

**Ausführungsnachweise gehören außerhalb der Modellprosa.** Speichere Commit-Kennung, geänderte Dateien, Testbefehl, Exit-Code und PR-Kennung als Werkzeugergebnisse. Akzeptiere „Tests bestanden“ nicht von einem Modell ohne Testwerkzeug. Trenne Merge- und Deployment-Freigaben von der Erlaubnis, einen PR zu entwerfen.

Für eine echte Implementierung empfehlen sich frische Arbeitsverzeichnisse, eng begrenzte Repository-Tokens, Einschränkungen für Schreibpfade und ein Idempotenzschlüssel für die PR-Erstellung. Das sind empfohlene Anwendungskontrollen, keine vom reinen Textbeispiel demonstrierten SDK-Funktionen.

## Was unterscheidet Fusion vom Modell-Routing?

Routing bestimmt, welches Modell einen Aufruf bearbeitet. Bei Fusion delegiert ein Hauptagent eine Teilaufgabe an einen Sidekick mit eigenem Gesprächsverlauf. Die [Fusion-Dokumentation des SDK](https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/README.md) beschreibt dessen Konfiguration über `FusionOptions`. Getrennte Verläufe können verschiedene Arbeitsstränge unterstützen, beweisen aber keine Kostensenkung für deinen Anwendungsfall.

Teste Fusion getrennt vom sequenziellen Modellwechsel. Zähle Eingabe und Ausgabe beider Agenten, Wartezeiten, doppelte Untersuchung und Verifikation. Ein erhaltener Client-Verlauf ist außerdem kein anbieterübergreifender Prompt-Cache: Ein neuer Anbieter kann den Gesprächsinhalt erhalten, ohne die zwischengespeicherten Tokens des bisherigen Anbieters zu übernehmen. Miss die tatsächliche Cache-Nutzung, statt einen kostenlosen Wechsel anzunehmen.

Wachsende Verläufe können die Ersparnis eines kleineren Modells aufheben. Verwende aufgabenbezogene Nachweise und explizite Zusammenfassungen, erhalte aber alle Informationen zur Reproduktion des Fehlers. Anbieterübergreifendes Routing erweitert zudem den Kreis der Systeme, die Prompts oder Code erhalten können. Kläre diesen Datenfluss vor der Freigabe einer Modellstufe.

## Senkt Modell-Routing pro Turn tatsächlich die Agentenkosten?

**Nur wenn akzeptierte Arbeit bei der nötigen Qualität und Geschwindigkeit günstiger wird.** Eine billigere Einzelantwort reicht nicht. Berücksichtige im Messzeitraum Klassifikation, Generierung, Wiederholungen, Werkzeuge, Infrastruktur und zurechenbare manuelle Korrekturen.

`Kosten je akzeptierter Aufgabe = zurechenbare Gesamtkosten aller Versuche / Anzahl akzeptierter Aufgaben`

| Strategie | Begonnene Aufgaben | Gesamtkosten | Akzeptierte Aufgaben | Kosten je akzeptierter Aufgabe |
| --- | --- | --- | --- | --- |
| Vergleich mit festem Modell | 100 | 120 USD | 80 | 1,50 USD |
| Routing-Strategie | 100 | 90 USD | 50 | 1,80 USD |

In diesem erfundenen Beispiel sinken die Ausgaben um 25 %, die Kosten je akzeptierter Aufgabe steigen jedoch um 20 %. Außerdem bleibt mehr Arbeit unerledigt. Der richtige Nenner verändert die Entscheidung.

Vergleiche vier Varianten anhand derselben zurückgehaltenen Testaufgaben: das bisherige feste Modell, ein billigeres festes Modell, deterministisches Stufen-Routing und den automatischen Router. Halte Werkzeuge, Abnahmekriterien und Höchstbudgets vergleichbar. Berichte Ergebnisqualität, Korrekturzeit, Fallback-Häufigkeit und durchgängige p50-/p95-Latenz, nicht nur durchschnittliche Tokenkosten. Die umfassendere Rechnung erläutert unser [Leitfaden zu Kosten pro Agentenaktion](/de/blog/ai-agent-cost-per-action-2026/).

## Was muss ein LiteAgents-Pilot vor dem Produktivbetrieb beweisen?

Beginne mit reversibler Arbeit und einer kleinen Modell-Allowlist. Beobachte zunächst nur die vorgeschlagene Route, während der bewährte Ausgangsprozess die Aufgabe erledigt. Teste danach die tatsächliche geroutete Ausführung auf isolierten Kopien. So wird das Routing geprüft, ohne aus dem ersten Experiment bereits eine Produktions-Schreibberechtigung zu machen.

| Prüfung | Benötigter Nachweis |
| --- | --- |
| Paket- und API-Identität | Die erwarteten Imports funktionieren; freigegebene Quellen und Abhängigkeitsversionen sind dokumentiert. |
| Routing und Fallback | Stufenwahl, Klassifikationsfehler, fehlerhafte Antworten und unbekannte Stufen sind beobachtbar. |
| Unvollständige Ausführung | Timeouts, abgeschnittene Antworten und ausgeschöpfte max_turns dürfen nicht als erledigte Arbeit erscheinen. |
| Berechtigungen und Daten | Nicht freigegebene Anbieter, Dateien, Befehle und mandantenfremde Verläufe werden unabhängig vom Modell blockiert. |
| Abnahme und Rückkehr | Unabhängige Testaufgaben erfüllen vereinbarte Qualitäts-, Kosten- und Latenzgrenzen; die feste Modellstrategie bleibt verfügbar. |

Achte besonders auf `max_turns`. Die [geprüfte Werkzeugschleife](https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/src/liteagents/loop.py) erzeugt keine abschließende Antwort, wenn dieses Limit während der Werkzeugnutzung erreicht wird. Verfolge die letzte Assistentennachricht und behandle `stop_reason="tool_use"` als unvollständig. Ein zurückgegebener Nachrichtenstrom ist nicht automatisch ein erfolgreiches Geschäftsergebnis.

## Wann lohnt es sich, LiteAgents zu evaluieren?

LiteAgents ist interessant, wenn deine Anwendung Anbieterflexibilität benötigt und Aufgaben tatsächlich unterschiedliche Modellanforderungen haben. Weniger überzeugend ist es, wenn bereits ein einzelnes günstiges Modell ausreicht oder eine Migration wichtige Laufzeitkontrollen ohne Ersatz entfernen würde.

Der sinnvolle Weg ist überschaubar: Paket prüfen, Verhalten mit festem Modell reproduzieren, explizite Arbeitsschritte routen und automatische Klassifikation erst nach Prüfung von Schnittstelle und Wirtschaftlichkeit hinzufügen. Eine überzeugende Routing-Animation ersetzt keine Produktionsabnahme.

Bei der Umsetzung unterstützen [Wavects KI-Engineering-Leistungen](/de/services/artificial-intelligence/) bei Anwendungsintegration und Evaluation. Die [Twinsoft-AI-Fallstudie](/de/case-studies/twinsoft-ai/) liefert verwandten Projektkontext, keinen Nachweis eines LiteAgents-Einsatzes. Nutze die [QA-Checkliste vor dem Launch](/de/software-development-guide/software-qa-checklist-before-launch/) für Abnahmekriterien oder [besprich einen Pilot für Modell-Routing](/de/contact/) anhand eines realen Workflows und seiner bisherigen Ergebnisse.

## Fragen zu LiteAgents-Setup und Modell-Routing

### Kann LiteAgents verschiedene Modelle in einem Gespräch verwenden?

Ja. LiteAgentClient behält den Gesprächsverlauf über query-Aufrufe hinweg, während ein Router das Modell auswählt. Der geprüfte Jev-Adapter speichert die Wahl pro Nutzer-Turn. Andere Routing-Grenzen benötigen getrennte query-Aufrufe oder einen gezielt entwickelten eigenen Router.

### Wechselt LiteAgents automatisch nach jedem Werkzeugaufruf das Modell?

Der Routing-Hook läuft vor jeder Modellaufruf-Runde, aber der geprüfte Jev-Router verwendet innerhalb eines Nutzer-Turns seine gespeicherte Auswahl. Ein einzelner Auftrag wechselt deshalb nicht zwangsläufig zwischen Modellen für Planung, Implementierung und PR-Text.

### Warum lässt sich LiteAgentOptions nach der Installation nicht importieren?

Prüfe Paketidentität, aktive Python-Umgebung und lokale Dateien, die das Paket verdecken könnten. Am Prüftag verwies der öffentliche PyPI-Name auf ein anderes Projekt als BerriAIs SDK. Der Leitfaden verwendet deshalb einen expliziten Commit aus dem BerriAI-Repository.

### Funktioniert LiteAgents ohne TypeSafe-API-Schlüssel?

Ja. Ein festes Modell oder ein eigener Router benötigt keinen Jev-Klassifikationsdienst. Zugangsdaten der tatsächlichen Modellanbieter bleiben erforderlich. Der geprüfte Jev-Pfad nutzt TYPESAFE_API_KEY; sein Fallback bei fehlendem Schlüssel kann verdecken, dass keine Klassifikation stattgefunden hat.

### Warum verwendet mein LiteAgents-Lauf ständig fallback_model?

Mögliche Ursachen sind ein fehlender Schlüssel, ein gescheiterter Klassifikationsaufruf, eine ungültige Antwort oder eine unbekannte Stufe. Prüfe den Endpunkt und protokolliere den Auswahlgrund. Eine generierte Antwort oder ein Modellname allein beweist keine erfolgreiche Klassifikation.

### Ist LiteAgents ein direkt austauschbarer Ersatz für das Claude Agent SDK?

Abfrageschnittstelle und Nachrichtentypen sind vertraut, aber Werkzeuge, Berechtigungsdurchsetzung, Zustandsspeicherung und Laufzeitverhalten müssen separat geprüft werden. Geänderte Imports stellen nicht automatisch die Ausführungsumgebung von Claude Code wieder her.

### Behebt das Python-Beispiel tatsächlich ein Repository und öffnet einen PR?

Nein. Es demonstriert drei geroutete Entwurfs-Turns mit gemeinsamem Verlauf. Ein echter Coding-Workflow benötigt zusätzlich Repository-, Bearbeitungs-, Test- und Veröffentlichungswerkzeuge mit unabhängigen Berechtigungen und überprüften Ausführungsergebnissen.

### Wie sollten wir Routing-Einsparungen mit LiteAgents messen?

Vergleiche vollständig akzeptierte Aufgaben unter denselben Abnahmekriterien. Zähle alle Versuche, Klassifikationsaufrufe, Generierung, Werkzeuge, Wiederholungen und Korrekturen. Berichte Kosten je akzeptierter Aufgabe gemeinsam mit Qualität, Fallback-Quote und durchgängiger Latenz.

## Fazit

Dein Agent sollte nicht aus Gewohnheit immer dasselbe Modell verwenden. Diese Gewohnheit durch einen ungeprüften Router zu ersetzen, ist aber kein Fortschritt. Mache Workflow-Grenzen explizit, Fallbacks sichtbar und Werkzeugberechtigungen unabhängig. Ob Routing seinen Platz verdient, entscheiden akzeptierte Ergebnisse.

Modelle und Infrastruktur

## In diesem Cluster weiterlesen

Modellauswahl, Inferenzkosten, lokaler Betrieb, Kompression und Serving-Architektur.

[Mit dem Grundlagenartikel starten**LLMs in der EU selbst hosten: Wann sich Open Weights wirklich rechnen**](/de/blog/self-hosting-llms-eu-cost/)

- [mcp-memory-service: Gemeinsames Gedächtnis für Claude Code und Cursor](/de/blog/mcp-memory-service-claude-code-cursor/)
- [Claude Opus 5.5: Einsatzfälle, Prompts und Effort](/de/blog/claude-opus-5-5-best-use-cases-workflows/)
- [Laya und Jev im Unternehmen: 6 praktische Workflows](/de/blog/laya-jev-business-workflows-roi/)
- [Laya vs Jev: Benchmarks und das Risiko für KI-Startups](/de/blog/laya-vs-jev-benchmark-ai-startup-moat/)
- [Jev AI im Test: Entscheidungsmodelle für Agenten](/de/blog/jev-ai-decision-model-review/)

[**Zurück**](/de/blog/overview/)

[![Kevin Riedl](/img/team/kevin.webp)](/de/team/kevin-riedl/)

[Kevin Riedl](/de/team/kevin-riedl/) https://linkedin.com/in/wsdt

16 Min. Lesezeit · 25. Sep. 2026 Zuletzt geprüft 25. September 2026

[**Weiter**](/de/blog/jev-ai-decision-model-review/)

## Structured Data

```json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@id": "https://wavect.io/#organization",
      "@type": [
        "Organization",
        "ProfessionalService",
        "LocalBusiness"
      ],
      "employee": [
        {
          "@id": "https://wavect.io/team/kevin-riedl/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Kevin Riedl",
          "url": "https://wavect.io/team/kevin-riedl/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        },
        {
          "@id": "https://wavect.io/team/christof-jori/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Christof Jori",
          "url": "https://wavect.io/team/christof-jori/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        }
      ],
      "founder": [
        {
          "@id": "https://wavect.io/team/kevin-riedl/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Kevin Riedl",
          "url": "https://wavect.io/team/kevin-riedl/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        },
        {
          "@id": "https://wavect.io/team/christof-jori/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Christof Jori",
          "url": "https://wavect.io/team/christof-jori/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        }
      ],
      "legalRepresentative": [
        {
          "@id": "https://wavect.io/team/kevin-riedl/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Kevin Riedl",
          "url": "https://wavect.io/team/kevin-riedl/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        },
        {
          "@id": "https://wavect.io/team/christof-jori/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Christof Jori",
          "url": "https://wavect.io/team/christof-jori/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        }
      ],
      "name": "Wavect GmbH",
      "subjectOf": {
        "@id": "https://wavect.io/verified-claims.json#dataset",
        "@type": "Dataset",
        "creator": {
          "@id": "https://wavect.io/#organization",
          "@type": [
            "Organization",
            "ProfessionalService",
            "LocalBusiness"
          ]
        },
        "description": "A machine-readable registry of quantitative and qualitative claims published by Wavect, with review dates, localized page appearances and public third-party citations where available.",
        "inLanguage": "en",
        "isAccessibleForFree": true,
        "license": "https://creativecommons.org/licenses/by/4.0/",
        "name": "Wavect verified publication claims",
        "url": "https://wavect.io/verified-claims.json"
      },
      "url": "https://wavect.io/"
    },
    {
      "@id": "https://wavect.io/team/kevin-riedl/#person",
      "@type": "Person",
      "jobTitle": "Managing Director",
      "name": "Kevin Riedl",
      "sameAs": [
        "https://www.wikidata.org/wiki/Q139796365",
        "https://www.linkedin.com/in/wsdt",
        "https://github.com/wsdt"
      ],
      "url": "https://wavect.io/team/kevin-riedl/",
      "worksFor": {
        "@id": "https://wavect.io/#organization",
        "@type": [
          "Organization",
          "ProfessionalService",
          "LocalBusiness"
        ]
      }
    },
    {
      "@id": "https://wavect.io/team/christof-jori/#person",
      "@type": "Person",
      "jobTitle": "Managing Director",
      "name": "Christof Jori",
      "sameAs": [
        "https://www.wikidata.org/wiki/Q139796367",
        "https://www.linkedin.com/in/jocr77/",
        "https://github.com/jo-chris"
      ],
      "url": "https://wavect.io/team/christof-jori/",
      "worksFor": {
        "@id": "https://wavect.io/#organization",
        "@type": [
          "Organization",
          "ProfessionalService",
          "LocalBusiness"
        ]
      }
    },
    {
      "@id": "https://wavect.io/#website",
      "@type": "WebSite",
      "inLanguage": [
        "en",
        "de",
        "es",
        "zh"
      ],
      "name": "Wavect",
      "potentialAction": {
        "@type": "SearchAction",
        "query-input": "required name=search_term_string",
        "target": {
          "@type": "EntryPoint",
          "urlTemplate": "https://wavect.io/search/?q={search_term_string}"
        }
      },
      "publisher": {
        "@id": "https://wavect.io/#organization",
        "@type": [
          "Organization",
          "ProfessionalService",
          "LocalBusiness"
        ]
      },
      "url": "https://wavect.io/"
    },
    {
      "@id": "https://wavect.io/de/blog/liteagents-sdk-per-turn-model-routing/#webpage",
      "@type": "WebPage",
      "dateModified": "2026-09-25",
      "inLanguage": "de",
      "isPartOf": {
        "@id": "https://wavect.io/#website",
        "@type": "WebSite"
      },
      "lastReviewed": "2026-09-25",
      "url": "https://wavect.io/de/blog/liteagents-sdk-per-turn-model-routing/"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "abstract": "LiteAgents ist BerriAIs anbieterunabhängiges Python-SDK für Agenten mit einer query()-Schnittstelle nach dem Vorbild des Claude Agent SDK. Ein zustandsbehafteter Client kann den Gesprächsverlauf behalten und Modelle wechseln. Im geprüften Quellcode speichert der Jev-Router seine Wahl pro Nutzer-Turn, statt nach jedem Werkzeugergebnis neu zu klassifizieren. Prüfe Paketidentität, Klassifikations-Endpunkt, Werkzeugberechtigungen und Fallbacks vor dem Repository-Zugriff. Entscheidend sind Kosten je akzeptierter Aufgabe, nicht nur billigere Modellaufrufe.",
  "articleBody": " Blog-Übersicht/AI und Agents/Modelle und Infrastruktur LiteAgents SDK: Modell-Routing, Setup und Migration TL;DR LiteAgents ist BerriAIs anbieterunabhängiges Python-SDK für Agenten mit einer query()-Schnittstelle nach dem Vorbild des Claude Agent SDK. Ein zustandsbehafteter Client kann den Gesprächsverlauf behalten und Modelle wechseln. Im geprüften Quellcode speichert der Jev-Router seine Wahl pro Nutzer-Turn, statt nach jedem Werkzeugergebnis neu zu klassifizieren. Prüfe Paketidentität, Klassifikations-Endpunkt, Werkzeugberechtigungen und Fallbacks vor dem Repository-Zugriff. Entscheidend sind Kosten je akzeptierter Aufgabe, nicht nur billigere Modellaufrufe. Ein Login-Fehler ist keine einheitliche Aufgabe. Ursache finden, eine defensive Korrektur entwerfen, Tests prüfen und einen Pull Request erklären verlangen unterschiedliche Arbeit. Überall dasselbe große Modell einzusetzen, kann unnötig teuer sein. Alles dem billigsten Modell zu überlassen, kann noch teurer werden, sobald zusätzliche Versuche oder manuelle Korrekturen nötig sind. LiteAgents SDK macht die Modellwahl zu einem Bestandteil der Agenten-Laufzeit. Dieser Leitfaden beantwortet die Umsetzungsfragen: Was bedeutet „pro Turn“? Welches Paket ist gemeint? Wie funktioniert ein eigener Router? Was macht der Jev-Fallback tatsächlich? Und was ändert sich bei einer Migration vom Claude Agent SDK? Quellenprüfung: 25. September 2026. Aussagen zum Code beziehen sich auf BerriAI/liteagents, Commit 539a6e2. Die Beispiele wurden mit den Quellen abgeglichen, sind aber kein Live-Benchmark mit Modellanbietern und kein Nachweis eines LiteAgents-Kundenprojekts von Wavect. Was ist LiteAgents SDK, und welche Rolle spielt LiteLLM? LiteAgents ist BerriAIs Python-SDK für Agenten, die über eine vertraute query()-Schnittstelle mehrere Modellanbieter nutzen. Die Produktseite von LiteLLM beschreibt das Grundprinzip: Das Modell soll zur jeweiligen Arbeit passen, statt dauerhaft für den gesamten Agenten festzustehen. Die Ankündigung illustriert einen Login-Fix mit Claude Opus 4.8 für die Planung, GPT-5.4 mini für Implementierung und Tests sowie Claude Sonnet 4.6 für die PR-Beschreibung. Das sind Beispielrollen, keine durch Benchmarks bewiesene Rangfolge und keine Zusage, dass ein einzelner Prompt genau diese Abfolge erzeugt. Das geprüfte SDK-README dokumentiert feste Modelle, eigene Router, Jev-basierte Stufenwahl, einen zustandsbehafteten Client, MCP-Werkzeugadapter und einen separaten Fusion-Modus. LiteLLM stellt die darunterliegende Modellanbindung bereit. LiteAgents ergänzt Gesprächsführung und Werkzeugschleife. Hier geht es um die Integration dieses konkreten SDK. Für die übergeordnete Infrastrukturentscheidung gibt es unseren Vergleich von LLM-Gateways und Routern. Das Entscheidungsmodell selbst behandeln wir im technischen Jev-Überblick. Diese Entscheidungen sollten getrennt bleiben. Wechselt LiteAgents nach jedem Werkzeugaufruf das Modell? Nicht automatisch mit dem geprüften Jev-Router. Ein Nutzer-Turn ist etwas anderes als eine Modellaufruf-Runde. Die Client-Implementierung erhöht den Turn-Zähler für jedes agent.query(prompt). Innerhalb dieses Aufrufs können mehrere Modellantworten und Werkzeugergebnisse entstehen. Die Implementierung der Werkzeugschleife fragt vor jeder Modellaufruf-Runde den Router. Der Jev-Router speichert die gewählte Route jedoch unter context.turn. Weitere Runden desselben Nutzer-Turns verwenden diese Wahl erneut. Ein eigener Router kann den aktuellen Verlauf auswerten und anders reagieren; der eingebaute Jev-Pfad klassifiziert nicht nach jedem Werkzeugergebnis neu. Drei Grenzen, die nicht verwechselt werden sollten GrenzeGeprüftes VerhaltenFolge für die Umsetzung Nutzer-TurnEin query-Aufruf beim zustandsbehafteten ClientPlanung, Entwurf und Zusammenfassung bei Bedarf als getrennte Turns abbilden. Modellaufruf-RundeEine Modellantwort, gegebenenfalls gefolgt von Werkzeugen und einer weiteren AntwortDer Routing-Hook läuft erneut, Jev liefert aber die gespeicherte Wahl dieses Turns. Fusion-DelegationEin Hauptagent übergibt Arbeit an einen Sidekick mit eigenem VerlaufGetrennt vom sequenziellen Modellwechsel bewerten. Unterscheide außerdem Gesprächskontext und Routing-Kontext. Der Jev-Adapter übermittelt dem Klassifikator den aktuellen Prompt und die Stufenbeschreibungen, nicht den gesamten Verlauf. „Mach den nächsten Teil“ liefert ihm deshalb weniger Information als eine eigenständig verständliche Aufgabenbeschreibung. Erzeuge den Router pro Client: Sein nach Turn-Nummern organisierter Cache sollte nicht ungeprüft zwischen unabhängigen Sitzungen geteilt werden. Wie installierst du das richtige LiteAgents-Paket? Prüfe die Repository-Identität, bevor du einen Installationsbefehl übernimmst. Die geprüften Paketmetadaten von BerriAI nennen Python ab Version 3.10 und die Paketversion 0.1.0. Am Prüftag zeigte der öffentliche PyPI-Eintrag namens liteagents dagegen ein anderes Projekt, Version 0.0.2, aus Januar 2025. Gleiche Namen bedeuten nicht gleiche",
  "articleSection": "KI-Engineering",
  "author": {
    "@id": "https://wavect.io/team/kevin-riedl/#person",
    "@type": "Person",
    "name": "Kevin Riedl",
    "sameAs": [
      "https://www.wikidata.org/wiki/Q139796365",
      "https://www.linkedin.com/in/wsdt",
      "https://github.com/wsdt"
    ],
    "url": "https://wavect.io/team/kevin-riedl/"
  },
  "citation": [
    {
      "@type": "WebPage",
      "name": "Produktseite von LiteLLM",
      "url": "https://www.litellm.ai/liteagents"
    },
    {
      "@type": "WebPage",
      "name": "Ankündigung",
      "url": "https://www.linkedin.com/posts/reffajnaahsi_your-agent-shouldnt-use-the-same-model-for-activity-7508328914746806272-UeCq"
    },
    {
      "@type": "WebPage",
      "name": "geprüfte SDK-README",
      "url": "https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/README.md"
    },
    {
      "@type": "WebPage",
      "name": "Client-Implementierung",
      "url": "https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/src/liteagents/agent.py"
    },
    {
      "@type": "WebPage",
      "name": "Implementierung der Werkzeugschleife",
      "url": "https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/src/liteagents/loop.py"
    },
    {
      "@type": "WebPage",
      "name": "Jev-Router",
      "url": "https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/src/liteagents/routers/jev.py"
    },
    {
      "@type": "WebPage",
      "name": "Paketmetadaten von BerriAI",
      "url": "https://github.com/BerriAI/liteagents/blob/539a6e2a9669433ffa9034ae262718e30c4f80b6/pyproject.toml"
    },
    {
      "@type": "WebPage",
      "name": "öffentliche PyPI-Eintrag namens liteagents",
      "url": "https://pypi.org/project/liteagents/"
    },
    {
      "@type": "WebPage",
      "name": "pip-Dokumentation zur VCS-Installation",
      "url": "https://pip.pypa.io/en/stable/topics/vcs-support/"
    },
    {
      "@type": "WebPage",
      "name": "öffentliche Modellreferenz von TypeSafe",
      "url": "https://docs.typesafe.ai/models"
    },
    {
      "@type": "WebPage",
      "name": "LiteLLM dokumentiert Anbieter-Failover separat",
      "url": "https://docs.litellm.ai/docs/proxy/reliability"
    },
    {
      "@type": "WebPage",
      "name": "Anthropics Übersicht zum Agent SDK",
      "url": "https://code.claude.com/docs/en/agent-sdk/overview"
    },
    {
      "@type": "WebPage",
      "name": "LiteLLM-Router-Dokumentation",
      "url": "https://docs.litellm.ai/docs/routing"
    }
  ],
  "dateModified": "2026-09-25",
  "datePublished": "2026-09-25",
  "description": "LiteAgents ist BerriAIs anbieterunabhängiges Python-SDK für Agenten mit einer query()-Schnittstelle nach dem Vorbild des Claude Agent SDK. Ein zustandsbehafteter Client kann den Gesprächsverlauf behalten und Modelle wechseln. Im geprüften Quellcode speichert der Jev-Router seine Wahl pro Nutzer-Turn, statt nach jedem Werkzeugergebnis neu zu klassifizieren. Prüfe Paketidentität, Klassifikations-Endpunkt, Werkzeugberechtigungen und Fallbacks vor dem Repository-Zugriff. Entscheidend sind Kosten je akzeptierter Aufgabe, nicht nur billigere Modellaufrufe.",
  "headline": "LiteAgents SDK: Modell-Routing, Setup und Migration",
  "image": "https://wavect.io/img/blog/headers/header_liteagents-sdk-per-turn-model-routing.svg",
  "inLanguage": "de",
  "keywords": "LiteAgents SDK, Modell-Routing, KI-Engineering",
  "mainEntityOfPage": {
    "@id": "https://wavect.io/de/blog/liteagents-sdk-per-turn-model-routing/",
    "@type": "WebPage"
  },
  "publisher": {
    "@id": "https://wavect.io/#organization",
    "@type": [
      "Organization",
      "ProfessionalService",
      "LocalBusiness"
    ]
  },
  "url": "https://wavect.io/de/blog/liteagents-sdk-per-turn-model-routing/",
  "wordCount": 2954
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "item": "https://wavect.io/de/",
      "name": "Startseite",
      "position": 1
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/de/blog/overview/",
      "name": "Blog-Übersicht",
      "position": 2
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/de/blog/topics/ai-agents/",
      "name": "AI und Agents",
      "position": 3
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/de/blog/clusters/models-infrastructure/",
      "name": "Modelle und Infrastruktur",
      "position": 4
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/de/blog/liteagents-sdk-per-turn-model-routing/",
      "name": "LiteAgents SDK: Modell-Routing, Setup und Migration",
      "position": 5
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Ja. LiteAgentClient behält den Gesprächsverlauf über query-Aufrufe hinweg, während ein Router das Modell auswählt. Der geprüfte Jev-Adapter speichert die Wahl pro Nutzer-Turn. Andere Routing-Grenzen benötigen getrennte query-Aufrufe oder einen gezielt entwickelten eigenen Router."
      },
      "name": "Kann LiteAgents verschiedene Modelle in einem Gespräch verwenden?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Der Routing-Hook läuft vor jeder Modellaufruf-Runde, aber der geprüfte Jev-Router verwendet innerhalb eines Nutzer-Turns seine gespeicherte Auswahl. Ein einzelner Auftrag wechselt deshalb nicht zwangsläufig zwischen Modellen für Planung, Implementierung und PR-Text."
      },
      "name": "Wechselt LiteAgents automatisch nach jedem Werkzeugaufruf das Modell?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Prüfe Paketidentität, aktive Python-Umgebung und lokale Dateien, die das Paket verdecken könnten. Am Prüftag verwies der öffentliche PyPI-Name auf ein anderes Projekt als BerriAIs SDK. Der Leitfaden verwendet deshalb einen expliziten Commit aus dem BerriAI-Repository."
      },
      "name": "Warum lässt sich LiteAgentOptions nach der Installation nicht importieren?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Ja. Ein festes Modell oder ein eigener Router benötigt keinen Jev-Klassifikationsdienst. Zugangsdaten der tatsächlichen Modellanbieter bleiben erforderlich. Der geprüfte Jev-Pfad nutzt TYPESAFE_API_KEY; sein Fallback bei fehlendem Schlüssel kann verdecken, dass keine Klassifikation stattgefunden hat."
      },
      "name": "Funktioniert LiteAgents ohne TypeSafe-API-Schlüssel?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Mögliche Ursachen sind ein fehlender Schlüssel, ein gescheiterter Klassifikationsaufruf, eine ungültige Antwort oder eine unbekannte Stufe. Prüfe den Endpunkt und protokolliere den Auswahlgrund. Eine generierte Antwort oder ein Modellname allein beweist keine erfolgreiche Klassifikation."
      },
      "name": "Warum verwendet mein LiteAgents-Lauf ständig fallback_model?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Abfrageschnittstelle und Nachrichtentypen sind vertraut, aber Werkzeuge, Berechtigungsdurchsetzung, Zustandsspeicherung und Laufzeitverhalten müssen separat geprüft werden. Geänderte Imports stellen nicht automatisch die Ausführungsumgebung von Claude Code wieder her."
      },
      "name": "Ist LiteAgents ein direkt austauschbarer Ersatz für das Claude Agent SDK?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Nein. Es demonstriert drei geroutete Entwurfs-Turns mit gemeinsamem Verlauf. Ein echter Coding-Workflow benötigt zusätzlich Repository-, Bearbeitungs-, Test- und Veröffentlichungswerkzeuge mit unabhängigen Berechtigungen und überprüften Ausführungsergebnissen."
      },
      "name": "Behebt das Python-Beispiel tatsächlich ein Repository und öffnet einen PR?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Vergleiche vollständig akzeptierte Aufgaben unter denselben Abnahmekriterien. Zähle alle Versuche, Klassifikationsaufrufe, Generierung, Werkzeuge, Wiederholungen und Korrekturen. Berichte Kosten je akzeptierter Aufgabe gemeinsam mit Qualität, Fallback-Quote und durchgängiger Latenz."
      },
      "name": "Wie sollten wir Routing-Einsparungen mit LiteAgents messen?"
    }
  ]
}
```
