Ein Reasoning-Modell denkt nach, bevor es antwortet, und bei den meisten OpenAI-kompatiblen APIs kommt beides aus einem Budget: max_tokens. Setzen Sie es wie bei einem Modell ohne Reasoning, also ein paar hundert Tokens für eine kurze Antwort, kommen manche Antworten leer mit finish_reason: "length" zurück. Die schnelle Lösung steht unter warum ein Reasoning-Modell eine leere Antwort liefert. Dieser Beitrag zeigt die Methode hinter einem Budget, dem Sie vertrauen können: messen, aus Perzentilen bemessen, das Kontextfenster beachten und mit den Antworten umgehen, die trotzdem abgeschnitten werden.
Was Reasoning kostet und wie Sie es senken, lesen Sie unter Reasoning-Tokens: warum Sie für mehr Output zahlen, als Sie sehen.
Warum ist das Budget vor der Antwort aufgebraucht?
Das Modell erzeugt der Reihe nach: erst das Reasoning, dann die sichtbare Antwort. Jedes Token von beidem zählt zu max_tokens. Die Doku von BroadNet sagt das für DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B: „the reasoning counts toward max_tokens“ (Übersetzung: das Reasoning zählt zu max_tokens), und bei einem kleinen Limit „the answer comes back empty“ (Übersetzung: die Antwort kommt leer zurück). Die Chat-Completions-Referenz von OpenAI definiert max_completion_tokens genauso, als Obergrenze „including visible output tokens and reasoning tokens“ (Übersetzung: einschließlich sichtbarer Output-Tokens und Reasoning-Tokens).
Die richtige Frage lautet also nicht „Wie lang ist meine Antwort?“, sondern „Wie lang sind Reasoning und Antwort zusammen, bei dieser Aufgabe, mit diesem Effort?“ Das schwankt stärker, als viele erwarten. Laut dem Leitfaden von OpenAI können seine Modelle je nach Problem „anywhere from a few hundred to tens of thousands of reasoning tokens“ (Übersetzung: zwischen einigen hundert und zehntausenden Reasoning-Tokens) erzeugen.
Kostet ein größeres max_tokens mehr?
Nein. Das ist der häufigste Grund für zu knappe Budgets. max_tokens ist eine Obergrenze. Abgerechnet werden die tatsächlich erzeugten Tokens. Eine Antwort, die 1.800 Tokens braucht, kostet bei einer Obergrenze von 4.000 genauso viel wie bei 40.000.
Was eine knappe Obergrenze kostet:
| Obergrenze vs. Bedarf | Was Sie zahlen | Was Sie bekommen |
|---|---|---|
| Obergrenze über dem Bedarf | Erzeugte Tokens | Die Antwort |
| Obergrenze unter dem Bedarf | Die volle Obergrenze, komplett Reasoning | Nichts Brauchbares, dazu ein Retry |
Ein Beispiel: Angenommen, ein Viertel Ihrer Aufrufe braucht mehr als 1.000 Tokens. Mit max_tokens=1000 rechnet jeder dieser Aufrufe 1.000 Output-Tokens Denken ab, liefert nichts und wird wiederholt. Das sind im Schnitt 250 verschwendete Output-Tokens pro Aufruf über alle Aufrufe, noch vor den Retries selbst, plus die Latenz einer zweiten Anfrage. Mit einer Obergrenze von 4.000 wird nichts verschwendet. Bei Qwen3.8 27B kostet Output $2.17 pro 1 Mio. Tokens, die Verschwendung summiert sich bei Volumen also.
Das eigentliche Risiko einer hohen Obergrenze ist eine ausufernde Antwort: ein Modell, das in eine Schleife gerät oder zu viel nachdenkt und weit mehr als nötig erzeugt. Eine harte Obergrenze begrenzt das. Wählen Sie sie anhand von Daten, wie unten beschrieben.
Wie messen Sie, was eine Aufgabe braucht?
Lassen Sie echte Prompts eines Aufgabentyps mit großzügiger Obergrenze laufen und erfassen Sie die Completion-Tokens und den Reasoning-Anteil. Wenn das Modell es meldet, liefert usage.completion_tokens_details.reasoning_tokens den Reasoning-Teil; die Doku von BroadNet listet dieses Feld.
import os
from openai import OpenAI
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/qwen3.8-27b"
def measure(prompts, ceiling=16_000, **kw):
"""Run real prompts with a generous ceiling and return per-call token counts."""
rows = []
for p in prompts:
r = client.chat.completions.create(model=MODEL, max_tokens=ceiling,
messages=[{"role": "user", "content": p}], **kw)
u, d = r.usage, r.usage.completion_tokens_details
reasoning = (d.reasoning_tokens or 0) if d else 0
rows.append({"reasoning": reasoning, "answer": u.completion_tokens - reasoning,
"finish": r.choices[0].finish_reason})
return rows
def pct(values, q):
values = sorted(values)
return values[min(len(values) - 1, int(q * len(values)))]
def recommend(rows, margin=1.2):
total = [r["reasoning"] + r["answer"] for r in rows]
return {"p50": pct(total, 0.5), "p95": pct(total, 0.95), "max": max(total),
"max_tokens": int(pct(total, 0.95) * margin),
"cut_off": sum(r["finish"] == "length" for r in rows)}
# print(recommend(measure(my_prompts))) # default effort
# print(recommend(measure(my_prompts, reasoning_effort="low")))
Regeln für eine Zahl, der Sie vertrauen können:
- Ein Aufgabentyp pro Durchlauf. Klassifikation, Extraktion, Code-Review und Planung haben sehr unterschiedliche Verteilungen. Ein globales
max_tokensverschwendet entweder Geld für Retries oder lässt ausufernde Antworten durch. - 50 oder mehr echte Prompts. Das 95. Perzentil von zehn Stichproben ist einfach die größte davon.
- Bei jedem genutzten Effort messen.
reasoning_effort="low"verändert die Verteilung. BroadNet dokumentiertlow; testen Sie andere Werte, bevor Sie sich darauf verlassen. - Ist
cut_offnicht null, Obergrenze erhöhen und erneut messen. Eine abgeschnittene Stichprobe verbirgt ihre wahre Länge. - Neu messen, wenn sich Modell oder Prompt ändert. Eine neue Modellversion kann mehr oder weniger nachdenken.
Setzen Sie dann max_tokens pro Aufgabe anhand von recommend(). Das 95. Perzentil plus 20 % lässt die meisten Aufrufe deutlich unter der Obergrenze und schickt nur den seltenen langen Fall in den Retry-Pfad unten. Das kostenlose Tool für Reasoning-Token-Budgets erledigt diese Rechnung in Ihrem Browser, sobald Sie Ihre Zahlen haben.
Wie begrenzt das Kontextfenster das Budget?
Das Kontextfenster fasst Prompt und Antwort zusammen. Der Preis-Feed von BroadNet definiert context_length als „the most tokens one request can hold, prompt and answer together“ (Übersetzung: die maximale Zahl an Tokens, die eine Anfrage fassen kann, Prompt und Antwort zusammen). Also:
max_tokens ≤ Kontextlänge − Prompt-Tokens
| Modell | Kontext | Platz für max_tokens bei einem Prompt von 200.000 Tokens |
|---|---|---|
| GLM 5.3 | 1.048.576 | 848.576 |
| DeepSeek V4.1 Flash | 1.048.576 | 848.576 |
| Qwen3.8 27B | 262.144 | 62.144 |
Das zählt bei Arbeit mit langem Kontext. Ein Agent, dessen Verlauf bei Qwen3.8 27B auf 250.000 Tokens angewachsen ist, hat nur noch etwa 12.000 Tokens für Denken und Antwort. Aufgaben mit langem Kontext brauchen zudem oft mehr Reasoning; prüfen Sie den verbleibenden Platz also im Moment des Aufrufs, nicht einmalig beim Start. Kontextfenster und der Kontextfenster-Rechner helfen bei der Einschätzung.
Was tun, wenn eine Antwort trotzdem abgeschnitten wird?
Prüfen Sie finish_reason bei jedem Aufruf. Ist es length, fehlt die Antwort oder ist unvollständig, selbst wenn content etwas Text enthält. Parsen Sie sie nicht, als wäre sie vollständig; ein abgeschnittenes JSON-Objekt ist eine häufige Fehlerquelle weiter hinten in der Pipeline (Structured Output).
Wiederholen Sie mit doppeltem Budget, innerhalb des Platzes, den der Kontext lässt, bis zu einer harten Obergrenze:
import json, urllib.request
FEED = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
CONTEXT = {m["id"]: m.get("context_length") for m in FEED["models"]}
def ask(model, messages, budget=4_000, hard_cap=32_000, **kw):
"""Retry a cut-off reply with a doubled budget, never past the cap or the context window."""
while True:
r = client.chat.completions.create(model=model, messages=messages,
max_tokens=budget, **kw)
if r.choices[0].finish_reason != "length":
return r
room = CONTEXT[model] - r.usage.prompt_tokens # context holds prompt + answer
nxt = min(budget * 2, hard_cap, room)
if nxt <= budget:
raise RuntimeError(f"still cut off at max_tokens={budget}")
print(f"cut off at {budget}, retrying with {nxt}")
budget = nxt
Zwei Alternativen zum Verdoppeln, je nach Aufgabe:
- Retry mit
reasoning_effort="low"bei gleichem Budget. Bei einfachen Aufgaben denkt das Modell oft zu viel nach, und weniger Effort löst das ohne höhere Obergrenze. - Die Aufgabe aufteilen. Stößt eine Antwort immer wieder an eine hohe Obergrenze, verlangt die Anfrage meist zu viel auf einmal.
Loggen Sie jede abgeschnittene Antwort mit dem Aufgabentyp. Eine steigende Rate bedeutet, dass sich Prompt, Modell oder Eingabedaten geändert haben und das Budget neu gemessen werden muss. Retries sind neue Inferenzen und werden erneut abgerechnet; begrenzen Sie die Versuche also, wie unter lang laufende Agenten: Timeouts und Retries beschrieben.
Was ändert Streaming?
Mit stream=True läuft das Reasoning vor dem ersten sichtbaren Token, ein Reasoning-Modell kann am Anfang also wie hängend wirken. Zeigen Sie in einer Chat-Oberfläche einen „Denkt nach“-Zustand, bis Inhalt ankommt, und bemessen Sie Client-Timeouts für die Denkzeit, nicht nur für die Antwort.
Manche Server streamen auch den Reasoning-Text selbst, in einem eigenen Feld. Der Name ist nicht standardisiert: Die API von DeepSeek nutzt reasoning_content, und vLLM hat sein Feld von reasoning_content in reasoning umbenannt, mit der Warnung, dass alter Client-Code „could silently read an empty“ (Übersetzung: stillschweigend ein leeres) Feld lesen könnte. Die Doku von BroadNet dokumentiert kein Feld für Reasoning-Text; bauen Sie also keine Funktionen darauf, ohne die Rohantwort Ihres Modells zu prüfen. Wenn Sie es lesen, dann defensiv:
for chunk in stream:
if chunk.choices:
delta = chunk.choices[0].delta
thinking = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
# log or display `thinking` only if your provider actually sends it
if delta.content:
print(delta.content, end="")
elif chunk.usage: # last chunk, with include_usage
print("\nreasoning tokens:", getattr(chunk.usage.completion_tokens_details, "reasoning_tokens", None))
Die Usage im letzten Chunk erfordert stream_options={"include_usage": True}, was BroadNet dokumentiert. Mehr zu Streams im Streaming-Leitfaden und unter SSE erklärt.
Welchen Parameternamen sollten Sie senden?
| API | Parameter | Enthält Reasoning |
|---|---|---|
| OpenAI Chat Completions | max_completion_tokens (max_tokens veraltet) |
Ja |
| OpenAI Responses | max_output_tokens |
Ja |
| BroadNet Inference (Chat Completions) | max_tokens, wie dokumentiert |
Ja |
| vLLM-Server | max_tokens, optional thinking_token_budget |
Ja |
Wenn Sie Code zwischen Anbietern verschieben, senden Sie den Namen, den der Anbieter dokumentiert, und bestätigen Sie mit einem Testaufruf, dass das Limit greift. Ein stillschweigend ignoriertes Limit sieht gut aus, bis eine ausufernde Antwort kommt. Die Migrations-Checkliste behandelt die anderen Parameter, die sich ändern.
Wo BroadNet Inference passt
Die drei Reasoning-Modelle von BroadNet melden Reasoning-Tokens in usage, wenn das Modell sie liefert; die Messung oben funktioniert also wie geschrieben. DeepSeek V4.1 Flash und GLM 5.3 bieten mit 1.048.576 Tokens Kontext den meisten Platz. Qwen3.8 27B hat 262.144. Brauchen Sie für eine Aufgabe kein Reasoning, ist Gemma 4 VL 26B nicht als Reasoning-Modell gelistet und umgeht die Budgetfrage ganz. Bei einem DeepSeek-V4.1-Flash-Plan zum Festpreis kosten Denk-Tokens nichts pro Token, abgeschnittene Antworten kosten aber trotzdem Zeit; dieselbe Budgetierung gilt also. BroadNet dokumentiert keine separate Reasoning-Grenze; wenn Sie eine brauchen, nutzen Sie einen Anbieter oder selbst gehosteten Server, der sie bietet.
