Leitfaden zur Implementierung von Token-Budgets

Token-Budgets sind die operative Schicht der LLM-Kostenkontrolle. Attribution zeigt dir, wohin das Geld fließt; Budgets verhindern, dass es an Orte fließt, wo du es nicht möchtest. Ohne Budgets kann eine einzelne falsch konfigurierte Agentenschleife oder ein Anstieg des Benutzerverkehrs eine monatliche Zuweisung in Stunden aufbrauchen. Dieser Leitfaden behandelt die Implementierung von vier Arten von Token-Budgets in der Produktion mit Pseudocode für jedes Muster.

Budget-Typen

Limits pro Anfrage

Das einfachste Budget: Begrenzen Sie jede Anfrage mit max_tokens. Dies ist nicht optional – jede Produktionsanfrage sollte ein explizites Ausgabe-Token-Limit haben. Ohne es kann eine ausschweifende Modellantwort unerwartete Tokens verbrauchen und die Latenz erhöhen.

// Per-request budget enforcement
function callLLM(prompt, config):
    response = provider.complete(
        prompt: prompt,
        model: config.model,
        max_tokens: config.max_output_tokens,    // hard cap
        temperature: config.temperature
    )
    if response.usage.total_tokens > config.warn_threshold:
        log.warn("Request exceeded soft limit",
            tokens: response.usage.total_tokens,
            threshold: config.warn_threshold
        )
    return response

Kontingente pro Team

Team-Kontingente erfordern einen gemeinsamen Counter, der über Anfragen hinweg persistent ist. Das Muster: Überprüfen Sie das verbleibende Budget vor jedem Aufruf, lehnen Sie ab oder stufen Sie herab, wenn das Budget aufgebraucht ist.

// Team quota with Redis-backed counter
function checkTeamBudget(teamId, estimatedTokens):
    key = "budget:" + teamId + ":" + currentPeriod()
    remaining = redis.get(key) or getTeamQuota(teamId)

    if remaining < estimatedTokens:
        if remaining < estimatedTokens * 0.1:
            return DENY    // hard limit: reject request
        else:
            return DOWNGRADE  // soft limit: use cheaper model

    return ALLOW

function recordUsage(teamId, actualTokens):
    key = "budget:" + teamId + ":" + currentPeriod()
    redis.decrby(key, actualTokens)
    remaining = redis.get(key)
    if remaining < getTeamQuota(teamId) * 0.2:
        alert.quotaLow(teamId, remaining)

Budgets pro Zeitraum

Budgets pro Zeitraum verbinden Team-Kontingente mit einem Zeitfenster. Der Hauptunterschied: Sie benötigen einen Kulanzfrist-Mechanismus. Wenn ein Team 80 % seines monatlichen Budgets erreicht, senden Sie eine Warnung. Bei 100 % erlauben Sie eine konfigurierbare Kulanzfrist (z. B. 24 Stunden), bevor die harte Durchsetzung beginnt. Dies verhindert, dass ein Team am letzten Tag des Monats in der Mitte einer Aufgabe blockiert wird.

// Time-period budget with grace period
function enforceBudget(teamId):
    usage = getUsageForPeriod(teamId, currentMonth())
    limit = getTeamMonthlyLimit(teamId)

    if usage < limit * 0.8:
        return ALLOW

    if usage < limit * 1.0:
        alert.budgetWarning(teamId, usage, limit)
        return ALLOW   // soft warning zone

    if usage < limit * 1.1 and withinGracePeriod(teamId):
        alert.budgetExceeded(teamId, usage, limit)
        return ALLOW   // grace period: allow overage

    return DENY  // hard stop

Budgets pro Workflow

Multi-Step-Agents und Pipelines benötigen Budgets auf zwei Ebenen: pro Schritt (verhindert, dass ein einzelner Schritt zu viel verbraucht) und pro Ausführung (verhindert, dass die gesamte Pipeline ihre Zuweisung überschreitet). Verfolgen Sie beide im Workflow-Kontext.

// Workflow budget tracker
class WorkflowBudget:
    constructor(maxPerStep, maxTotal):
        this.maxPerStep = maxPerStep
        this.maxTotal = maxTotal
        this.spent = 0

    function callStep(stepFn, prompt):
        if this.spent >= this.maxTotal:
            return fallbackResponse("Budget exceeded")

        response = callLLM(prompt, {
            max_tokens: min(this.maxPerStep,
                           this.maxTotal - this.spent)
        })

        this.spent += response.usage.total_tokens
        return response

Schrittweise Herabstufung, wenn das Budget überschritten wird

Geben Sie nicht einfach einen Fehler zurück, wenn ein Budget erreicht wird. Stufen Sie schrittweise herab. Wechseln Sie zu einem günstigeren Modell (GPT-4o-mini statt GPT-4o), reduzieren Sie die Kontextfenster-Größe, überspringen Sie optionale Verarbeitungsschritte, oder geben Sie ein Teilergebnis mit einer Notiz zurück, dass die vollständige Verarbeitung eine Budget-Genehmigung erfordert. Die Benutzererfahrung sollte sich verschlechtern, nicht unterbrochen werden.

// Degradation chain
function callWithDegradation(prompt, config):
    if checkBudget(config.teamId, FULL_MODEL):
        return callLLM(prompt, { model: config.primaryModel })

    if checkBudget(config.teamId, CHEAP_MODEL):
        log.info("Downgrading model for budget")
        return callLLM(prompt, { model: config.fallbackModel })

    if checkBudget(config.teamId, MINIMAL_TOKENS):
        truncated = truncateContext(prompt, 50%)
        return callLLM(truncated, {
            model: config.fallbackModel,
            max_tokens: 256
        })

    return cachedOrFallback(prompt)

Überwachung der Budget-Gesundheit

Verfolgen Sie drei Metriken: Verbrauchsrate (Tokens verbraucht pro Stunde vs. Budget), Prognose (bei aktuellem Tempo, wann ist das Budget aufgebraucht) und Override-Zähler (wie oft wurde die Kulanzfrist verwendet). Wenn die Kulanzfrist-Nutzung 10 % der Gesamtanfragen übersteigt, ist das Budget für die Workload zu niedrig festgelegt.

Verwandte Ressourcen

• LLM-Budget-Governance - organisatorische Richtlinien hinter Budgets.
• Ausgabenschranken für Agenten - Budget-Muster für autonome Agenten.
• So begrenzen Sie Inferenzkosten - Provider-seitige Kostenkontrollen.

Möchten Sie dies auf Ihre eigenen LLM-Ausgaben anwenden? FinOps LLM führt eine kostenlose Überprüfung Ihrer KI-Kosten durch und zeigt, wo die Einsparungen sind. Kostenlose Überprüfung buchen →

Zurück zu Forschung