Wie sich Reasoning-Modelle unterscheiden
Interne Chain-of-Thought gegenüber Standardmodellen: Was sich für Prompt-Autorinnen und -Autoren ändert.
Wie sich Reasoning-Modelle unterscheiden ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Prompt Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.
Was sind Reasoning-Modelle
Reasoning-Modelle sind LLMs, die speziell dafür trainiert und konfiguriert wurden, vor der Ausgabe einer Antwort eine längere interne Überlegung durchzuführen. Zu den Beispielen gehören die o1/o3/o4-Reihe von OpenAI und Claude von Anthropic mit aktiviertem Extended Thinking.
Im Gegensatz zu Standardmodellen, die Text direkt aus Ihrem Prompt Token für Token erzeugen, erstellen Reasoning-Modelle zunächst eine lange interne Gedankenkette und fassen sie anschließend zu einer endgültigen Antwort zusammen.
Standard- und Reasoning-Modelle: Was Sie sehen
Aus Sicht des API-Nutzers besteht der Unterschied in Folgendem:
- Standardmodell: Eingabe → Ausgabe (schnell, direkt)
- Reasoning-Modell: Eingabe → [interner Denkprozess, verborgen oder gestreamt] → Ausgabe (langsamer, bei schwierigen Problemen genauer)
Der Denkprozess ist der private Notizbereich des Modells. Er kann Fehlversuche, Selbstkorrekturen und Zwischenberechnungen enthalten, die nie in der endgültigen Antwort erscheinen.
OpenAI-o-Serie: API-Verhalten
Die Modelle o1/o3/o4 von OpenAI verarbeiten den Denkprozess intern — standardmäßig sehen Sie die Reasoning-Tokens nicht. Sie können die Anzahl der Tokens des Denkprozesses in den Nutzungsmetadaten beobachten, nicht jedoch deren Inhalt.
import openai
client = openai.OpenAI(api_key='sk-...')
# o3 — reasoning happens internally
response = client.chat.completions.create(
model='o3',
messages=[
{'role': 'user', 'content': 'Solve: A train leaves Chicago at 9am going 60mph. Another leaves NYC at 10am going 80mph. If the distance is 790 miles, when do they meet?'}
],
# reasoning_effort='high' # Optional: 'low', 'medium', 'high'
)
print(response.choices[0].message.content)
# Check how many tokens were used for thinking:
print('Input tokens:', response.usage.prompt_tokens)
print('Output tokens:', response.usage.completion_tokens)Claude Extended Thinking: API-Verhalten
Anthropics Claude stellt über die API Tokens des erweiterten Denkprozesses bereit. Sie können den Reasoning-Prozess des Modells in Echtzeit streamen und beobachten. Der Inhalt des Denkprozesses erscheint vor der endgültigen Antwort.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
# Enable extended thinking
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=16000,
thinking={
'type': 'enabled',
'budget_tokens': 10000 # Max tokens for thinking
},
messages=[{
'role': 'user',
'content': 'What is the 100th prime number?'
}]
)
# Response contains both thinking blocks and text blocks
for block in response.content:
if block.type == 'thinking':
print('THINKING:', block.thinking[:200], '...')
elif block.type == 'text':
print('ANSWER:', block.text)Tokens des Denkprozesses streamen
Sie können den erweiterten Denkprozess in Echtzeit streamen und sehen, wie sich die Überlegungen des Modells entfalten. Das ist für die UX nützlich — etwa um eine „Denken“-Animation anzuzeigen oder fortgeschrittenen Nutzern zu ermöglichen, den Denkprozess zu beobachten.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def stream_with_thinking(question):
with client.messages.stream(
model='claude-opus-4-5',
max_tokens=16000,
thinking={'type': 'enabled', 'budget_tokens': 8000},
messages=[{'role': 'user', 'content': question}]
) as stream:
current_block_type = None
for event in stream:
# Track which block type we're in
if hasattr(event, 'type'):
if 'thinking' in str(event.type):
current_block_type = 'thinking'
elif 'text' in str(event.type):
current_block_type = 'text'
# Print text delta
if hasattr(event, 'delta') and hasattr(event.delta, 'text'):
prefix = '[THINK] ' if current_block_type == 'thinking' else '[ANS] '
print(prefix + event.delta.text, end='', flush=True)
stream_with_thinking('Explain why P != NP is unproven.')Was intern geschieht: Der Notizbereich
Der interne Denkprozess des Modells ist ein Notizbereich, in dem es:
- mehrere Ansätze erkunden kann, bevor es sich festlegt
- Berechnungen durchführen und überprüfen kann
- eigene Fehler erkennen und zurückgehen kann
- Randfälle berücksichtigen kann
- mehrstufige Lösungen planen kann
Diese interne Überlegung ist der Grund, warum Reasoning-Modelle Standardmodelle bei schwierigen Aufgaben in Mathematik, Programmierung und strategischer Planung deutlich übertreffen — sie führen im Grunde eine Literaturrecherche durch, bevor sie schreiben.
budget_tokens: Denktiefe steuern
budget_tokens (Claude) oder reasoning_effort (OpenAI) steuert, wie intensiv das Modell nachdenkt. Mehr Denkaufwand führt bei schwierigen Problemen zu höherer Genauigkeit, verursacht aber auch höhere Kosten und Latenz.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def ask_with_budget(question, budget):
r = client.messages.create(
model='claude-opus-4-5',
max_tokens=budget + 2048, # must exceed budget_tokens
thinking={'type': 'enabled', 'budget_tokens': budget},
messages=[{'role': 'user', 'content': question}]
)
thinking_tokens = sum(
len(b.thinking.split()) * 1.3 # rough estimate
for b in r.content if b.type == 'thinking'
)
answer = next(b.text for b in r.content if b.type == 'text')
return answer, int(thinking_tokens)
# Same hard question with different budgets
q = 'Prove that the square root of 2 is irrational.'
ans_small, tok_small = ask_with_budget(q, 1024)
ans_large, tok_large = ask_with_budget(q, 8000)
print(f'Small budget ({tok_small} thinking tokens): {ans_small[:100]}')
print(f'Large budget ({tok_large} thinking tokens): {ans_large[:100]}')Temperature und Reasoning-Modelle
Reasoning-Modelle verhalten sich bei Temperature-Einstellungen anders:
- Für OpenAI o-series ist die Temperature standardmäßig auf 1 gesetzt und kann nicht immer geändert werden
- Bei Claude extended thinking wird die Temperature während des Denkens typischerweise auf 1 gesetzt
Versuchen Sie nicht, das Verhalten von Reasoning-Modellen über die Temperature zu steuern – verwenden Sie stattdessen budget_tokens oder reasoning_effort.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
# For Claude with extended thinking, temperature=1 is the default
# and best practice
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=10000,
temperature=1, # Required to be 1 when extended thinking is enabled
thinking={
'type': 'enabled',
'budget_tokens': 5000
},
messages=[{
'role': 'user',
'content': 'Write a Python function to find all prime numbers up to N.'
}]
)
print(response.content[-1].text[:300])Leistungsbenchmarks: Wo Reasoning überlegen ist
Reasoning-Modelle übertreffen Standardmodelle besonders deutlich in folgenden Bereichen:
- Wettbewerbsmathematik: AIME, AMC (o3 nahezu auf dem Niveau menschlicher Experten)
- Komplexe Programmierung: Competitive Programming (Codeforces)
- Wissenschaftliches Schlussfolgern: GPQA (Wissenschaft auf Hochschulniveau)
- Mehrstufige Logik: Probleme, die schrittweise Schlussfolgerungen erfordern
Bei einfachen Aufgaben wie Grammatik, Zusammenfassungen und faktischen Fragen und Antworten erzielen Standardmodelle bei 10- bis 100-mal geringeren Kosten gleich gute Ergebnisse.
Die Realität der Latenz
Reasoning-Modelle sind langsam. Ein schwieriges Problem mit hohem Reasoning-Aufwand kann 30–60 Sekunden dauern. Planen Sie Ihre UX entsprechend:
- Zeigen Sie Fortschrittsanzeigen wie „Denken …“ an
- Verwenden Sie Streaming, um verfügbare Teilergebnisse sofort anzuzeigen
- Verwenden Sie Reasoning-Modelle nicht für Echtzeit-Chats, bei denen die Latenz wichtig ist
- Berechnen Sie Ausgaben von Reasoning-Modellen für bekannte schwierige Fragen vorab
import time
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def timed_reasoning_call(question, budget):
start = time.time()
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=budget + 2000,
thinking={'type': 'enabled', 'budget_tokens': budget},
messages=[{'role': 'user', 'content': question}]
)
elapsed = time.time() - start
answer = next(b.text for b in response.content if b.type == 'text')
print(f'Latency: {elapsed:.1f}s | Answer: {answer[:100]}')
return answer
# Hard problem — expect 20-45 seconds
timed_reasoning_call(
'Design a database schema for a multi-tenant SaaS billing system.',
budget=8000
)Reasoning-Modelle und System-Prompts
Reasoning-Modelle reagieren anders auf System-Prompts als Standardmodelle. Da sie vor der Antwort intern abwägen, können sie komplexe mehrstufige Anweisungen in System-Prompts zuverlässiger befolgen.
Sehr lange und stark einschränkende System-Prompts können jedoch mit dem internen Reasoning in Konflikt geraten. Bewährte Vorgehensweise: Halten Sie System-Prompts für Reasoning-Modelle kurz – definieren Sie die Rolle und das Ausgabeformat und überlassen Sie die Strategie dem internen Reasoning des Modells.
Wissenscheck: Denken von Reasoning-Modellen
Was ist der entscheidende Unterschied zwischen dem, was der Autor des Prompts vorgibt, und dem, was intern in einem Reasoning-Modell geschieht?
Zusammenfassung: Wie sich Reasoning-Modelle unterscheiden
Reasoning-Modelle wie o1/o3 und Claude mit extended thinking führen vor ihrer Antwort intern eine Chain-of-Thought aus. Der Autor des Prompts gibt ein Problem vor; das Modell wägt intern verschiedene Ansätze ab, prüft sich selbst und gibt anschließend eine endgültige Antwort aus. Sie steuern die Denktiefe mit budget_tokens (Claude) oder reasoning_effort (OpenAI). Reasoning-Modelle sind besonders gut bei komplexer Mathematik, Programmierung und mehrstufiger Logik, aber 10- bis 100-mal teurer und 10- bis 100-mal langsamer als Standardmodelle. Verwenden Sie Streaming und Fortschrittsanzeigen, um die Latenz in Ihrer UX zu bewältigen.
Häufig gestellte Fragen
Ist die Lektion „Wie sich Reasoning-Modelle unterscheiden“ kostenlos?
Ja — der vollständige Text von „Wie sich Reasoning-Modelle unterscheiden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Prompt Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Wie sich Reasoning-Modelle unterscheiden“?
Interne Chain-of-Thought gegenüber Standardmodellen: Was sich für Prompt-Autorinnen und -Autoren ändert. Du übst AI Prompt Engineering mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Prompt Engineering zu starten?
Keine Vorkenntnisse erforderlich. AI Prompt Engineering auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Wie sich Reasoning-Modelle unterscheiden“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Prompt Engineering-Lektion Code schreiben und ausführen?
Ja. Jede AI Prompt Engineering-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Wie sich Reasoning-Modelle unterscheiden
- Effektive Prompts für Extended Thinking
- Wann Reasoning- und wann Standardmodelle einsetzen
- Abwägung von Kosten und Latenz