Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du .md an die URL der Seite anhängst.
Hauptnavigation
Design

GPT-5.6 verwenden

Lerne die Funktionen von GPT-5.6 kennen und erfahre, wie du die Modelle der GPT-5.6-Familie einsetzt und auf sie umsteigst.

Einführung

GPT-5.6 setzt neue Maßstäbe für Qualität und Effizienz bei komplexen Workflows im Produktivbetrieb. GPT-5.6 geht besonders sparsam mit Token um und gestaltet ansprechendere Frontends. Das zeigt sich im Layout, in der visuellen Hierarchie und in der Wahl der Gestaltungsmittel.

Mit GPT-5.6 ändert sich auch die Modellbenennung. Der Alias gpt-5.6 leitet Anfragen an gpt-5.6-sol weiter, das leistungsfähigste Modell der Familie. Verwende gpt-5.6-terra, wenn du hohe Leistung zu einem niedrigeren Preis brauchst, und gpt-5.6-luna, um ein hohes Anfragevolumen effizient zu verarbeiten.

Wenn du von GPT-5.5 oder GPT-5.4 umsteigst, beginne mit dem Reasoning-Aufwand, den du für GPT-5.5 oder GPT-5.4 eingestellt hast. Teste diese und die nächstniedrigere Stufe mit repräsentativen Aufgaben. GPT-5.6 erreicht häufig mit weniger Token die gleiche oder eine höhere Qualität. Welche Einstellung am besten passt, hängt von deinem Workload ab.

Neuerungen

  • Programmgesteuerte Tool-Aufrufe: GPT-5.6 kann JavaScript schreiben, um in einer gehosteten Laufzeitumgebung dafür freigegebene Tools aufzurufen, Ergebnisse zwischen Aufrufen weiterzugeben und Zwischenergebnisse zu verarbeiten. Nutze programmgesteuerte Tool-Aufrufe für klar abgegrenzte Workflows mit vielen Tool-Aufrufen, bei denen das Modell nicht nach jedem Schritt neu entscheiden muss. Programmgesteuerte Tool-Aufrufe sind mit ZDR kompatibel. Es fallen keine zusätzlichen Containerkosten an.
  • Multi-Agenten-Funktion [Beta]: Mit der Multi-Agenten-Funktion kann eine GPT-5.6-Instanz mehrere Subagenten parallel koordinieren und deren Ergebnisse zusammenführen. Ähnlich wie der Ultra-Modus in Codex kann das bei komplexen Aufgaben, die sich gut in unabhängige Teilaufgaben gliedern lassen, die Gesamtlaufzeit verkürzen und die Leistung verbessern. Die Multi-Agenten-Funktion ist in der Responses API als Beta verfügbar. Wir entwickeln sie anhand von Rückmeldungen aus der Entwicklercommunity weiter.
  • Explizites Prompt-Caching: Mit GPT-5.6 kannst du genau festlegen, welche wiederverwendbaren Prompt-Präfixe OpenAI im Cache speichert. Im impliziten Modus kannst du weiterhin das automatische Caching nutzen. Für Schreibvorgänge im Cache berechnet OpenAI das 1,25-Fache des Preises für Eingaben ohne Caching. Für Lesevorgänge gilt weiterhin ein ermäßigter Preis. Erfahre, wie du das Prompt-Caching konfigurierst.
  • Wiederverwendung von Reasoning: GPT-5.6 kann verfügbare Reasoning-Elemente über mehrere Gesprächsrunden hinweg wiederverwenden. Das kann die Qualität in längeren Dialogen und die Cache-Effizienz verbessern. Mit reasoning.context legst du das Verhalten fest. Erfahre, wie du Reasoning über mehrere Aufrufe hinweg beibehältst.
  • Reasoning-Aufwand auf Stufe Max: GPT-5.6 unterstützt max als Reasoning-Aufwand für anspruchsvolle Aufgaben, bei denen das Modell mehr Lösungswege untersuchen und Ergebnisse gründlicher prüfen muss. Wenn du derzeit xhigh verwendest, vergleiche beide Einstellungen anhand repräsentativer Workloads.
  • Pro-Modus: Im Pro-Modus kann GPT-5.6 mehr Rechenarbeit investieren, um schwierige Aufgaben zuverlässiger zu lösen und eine einzige abschließende Antwort zurückzugeben. Aktiviere ihn mit reasoning.mode: "pro", wenn Qualität wichtiger ist als Latenz und Token-Verbrauch. Erfahre, wie du den Pro-Modus verwendest.
  • Token-Effizienz: GPT-5.6 erreicht mit weniger Ausgabe-Token das Leistungsniveau eines Flagship-Modells.
  • Frontend-Design: GPT-5.6 erstellt ansprechendere, benutzerfreundlichere Websites und Anwendungen. Es trifft bessere Gestaltungsentscheidungen und setzt Layout und visuelle Hierarchie gezielter ein.
  • Verständnis der Absicht: GPT-5.6 kann aus dem Kontext besser ableiten, welches Ziel eine Person verfolgt und wie umfangreich die Bearbeitung sein soll. Deshalb musst du oft nicht jeden Schritt vorgeben. Gib weiterhin den fachlichen Kontext, zwingende Vorgaben und Erfolgskriterien an und lege fest, welche Aktionen eine Genehmigung erfordern. Sag dem Modell, bei welchen wichtigen Unklarheiten es nachfragen soll.
  • Bilddetails in Originalauflösung: Mit den Detailstufen original oder auto behält GPT-5.6 die Bildabmessungen bei. Ist eine Seite länger als 65.535 Pixel, wird das Bild so verkleinert, dass es diese Grenze einhält. Überschreitet es danach weiterhin die Obergrenze von 30.000 Patches, lehnt die API das Bild ab, ohne es weiter zu verkleinern. Große Bilder können mehr Eingabe-Token verbrauchen und die Latenz erhöhen. Erfahre, wie du die Detailstufe für Bilder auswählst.

Schutzmaßnahmen

Bei GPT-5.6 können Schutzmaßnahmen dazu führen, dass bestimmte Anfragen blockiert oder abgelehnt werden. Während das Modell seine Ausgabe erzeugt, prüfen Klassifikatoren sie in Echtzeit auf möglichen Missbrauch in den Bereichen Cybersicherheit und Biologie. Andere Anfragen können länger dauern, weil die Generierung mitten in der Ausgabe für einige Sekunden pausiert, bis die Klassifikatoren die Ausgabe synchron geprüft haben. Gelegentlich greifen die Schutzmaßnahmen auch bei legitimen Aufgaben. Das gilt besonders für Bereiche mit doppeltem Verwendungszweck, in denen sich defensive und offensive Aktivitäten anfangs ähneln können.

Wenn sich deine Anwendung an einzelne Endnutzende richtet, sende mit jeder Anfrage einen stabilen, datenschutzwahrenden safety_identifier. Eine Anleitung findest du im Abschnitt Sicherheitskennungen implementieren.

Wir entwickeln diese Schutzmaßnahmen laufend weiter, damit sie auch gezielten Umgehungsversuchen standhalten und wirksam bleiben. Gleichzeitig sollen legitime Aufgaben weiterhin möglich sein, etwa Code zu überprüfen, Schwachstellen zu erforschen, Patches zu entwickeln, Fehler zu beheben, Wissen über Sicherheit zu vermitteln und defensive Sicherheitstests durchzuführen.

Schnelleinstieg in die Migration

Mit Codex migrieren

Codex kann die in diesem Leitfaden empfohlenen Änderungen mit dem Skill OpenAI Docs umsetzen.

$openai-docs Stelle dieses Projekt auf die GPT-5.6-Modellfamilie um.

Wenn du diesen Skill in anderen Coding-Agenten verwenden möchtest, lade ihn aus dem Repository für OpenAI-Skills herunter.

API- und Modellparameter aktualisieren

  • Wähle das Zielmodell passend zum Workload. Verwende gpt-5.6-sol, wenn du die höchste Leistungsfähigkeit brauchst, gpt-5.6-terra für ein ausgewogenes Verhältnis von Modellintelligenz und Kosten oder gpt-5.6-luna, um ein hohes Anfragevolumen effizient zu verarbeiten. Der Alias gpt-5.6 leitet Anfragen an gpt-5.6-sol weiter.
  • Verwende die Responses API für Workflows mit Reasoning, Tool-Aufrufen und mehreren Gesprächsrunden.
  • Lege reasoning.effort gezielt fest. GPT-5.6 unterstützt none, low, medium, high, xhigh und max.
    • Wenn du von GPT-5.5 oder GPT-5.4 umsteigst, verwende deinen bisherigen Reasoning-Aufwand als Ausgangswert und vergleiche ihn mit der nächstniedrigeren Stufe.
    • Wenn du none verwendest, behalte diese Einstellung als Referenz für die Latenz bei. Teste zusätzlich low, wenn der Workflow von Reasoning oder Tool-Aufrufen profitiert.
    • Verwende medium als ausgewogenen Ausgangspunkt und low für Workloads, bei denen es auf geringe Latenz ankommt.
    • Verwende high oder xhigh, wenn ein höherer Reasoning-Aufwand die Qualität messbar verbessert.
    • Nutze max für die schwierigsten Workloads, bei denen Qualität Vorrang hat. Vergleiche max und xhigh, um für deinen Anwendungsfall das beste Verhältnis von Qualität, Latenz und Kosten zu finden.
  • Um den Pro-Modus zu verwenden, behalte dein gewähltes GPT-5.6-Modell bei und setze reasoning.mode in der Responses API auf pro. Wechsle dafür nicht zu einem separaten Modell-Slug für Pro. Wähle reasoning.effort unabhängig davon. Wenn du den Parameter weglässt, verwendet GPT-5.6 im Standard- und im Pro-Modus den Standardwert medium. Ein Anfragebeispiel und Einzelheiten zur Abrechnung findest du im Leitfaden zum Reasoning-Modus.
  • Lege anhand der weiterhin relevanten Reasoning-Schritte fest, wie viel früheres Reasoning das Modell wiederverwenden soll. GPT-5.6-Modelle verwenden standardmäßig all_turns, frühere Modelle current_turn.
    • Lass reasoning.context weg oder setze den Parameter auf auto, um den GPT-5.6-Standard all_turns zu verwenden. Prüfe im Feld reasoning.context der Antwort, welcher Modus tatsächlich verwendet wurde.
    • Setze reasoning.context auf all_turns, wenn Ziele, Annahmen und Prioritäten der Aufgabe über mehrere Gesprächsrunden hinweg gleich bleiben.
    • Wenn du all_turns verwendest, setze das Gespräch mit previous_response_id fort, damit das Modell auf das Reasoning aus früheren Antworten zugreifen kann.
    • Wenn du den Verlauf selbst verwaltest, bewahre frühere Nutzereingaben und sämtliche Ausgabeelemente jeder Antwort auf und sende sie erneut. Sende bei store: false oder bei einer Konfiguration ohne Datenaufbewahrung die verschlüsselten Reasoning-Elemente erneut, die die API standardmäßig zurückgibt.
    • Setze reasoning.context auf current_turn, wenn das frühere Reasoning nicht mehr relevant ist.
  • Prüfe dein Prompt-Caching. Du kannst implizites Caching ohne Codeänderungen weiterverwenden. Da Schreibvorgänge im Cache bei GPT-5.6 das 1,25-Fache des Preises für Eingaben ohne Caching kosten, erfasse cached_tokens und cache_write_tokens, um die Nettokosten zu ermitteln. Verwende explizite Haltepunkte oder prompt_cache_options.mode: "explicit", um unnötige Schreibvorgänge zu vermeiden, und ersetze prompt_cache_retention durch prompt_cache_options.ttl.
  • Für programmgesteuerte Tool-Aufrufe füge das Tool programmatic_tool_calling hinzu und gib geeignete Tools mit allowed_callers dafür frei. Passe deine Anwendung so an, dass sie program-Elemente, vom Programm ausgelöste Funktionsaufrufe und program_output-Elemente verarbeitet. Behalte für jeden Aufruf die call_id und die Zuordnung über caller bei. Beispiele für Anfragen und deren Fortsetzung findest du im Leitfaden zu programmgesteuerten Tool-Aufrufen.
    • Teste die Leistung des Workflows mit aktivierten programmgesteuerten Tool-Aufrufen (PTC) anhand repräsentativer Aufgaben. Vergleiche, wie gut die Aufgabe gelöst wurde, ob die abschließende Antwort vollständig ist und ob sie die erforderlichen Belege enthält. Vergleiche auch den gesamten Token-Verbrauch, die Latenz und die Kosten. Weniger Aufrufe, Gesprächsrunden oder Zwischenergebnisse sind nur dann eine Verbesserung, wenn die abschließende Antwort weiterhin die Qualitätsanforderungen erfüllt.

Empfehlungen für das Prompting

Prompts schlank halten

Wenn du wiederholte Anweisungen und Beispiele entfernst und Tool-Beschreibungen vereinfachst, kann das die Ergebnisse und die Token-Effizienz verbessern. In einer Stichprobe interner Evaluierungen von Coding-Agenten erzielten Konfigurationen mit schlankeren System-Prompts rund 10–15 % bessere Bewertungen. Gleichzeitig sank der gesamte Token-Verbrauch um 41–66 % und die Kosten sanken um 33–67 %. Die Ergebnisse hängen vom Workload ab. Nutze diese Spannen zur Orientierung und prüfe Änderungen anhand repräsentativer Aufgaben aus deiner eigenen Anwendung.

So vereinfachst du Prompts, ohne wichtige Vorgaben zu verlieren:

  • Beginne mit einem Prompt und einer Tool-Auswahl, die sich bereits bewährt haben. Entferne jeweils eine Gruppe von Anweisungen, Beispielen oder Tools und führe dann dieselben Evaluierungen erneut durch.
  • Formuliere jede Anweisung nur einmal.
  • Stelle nur die für die Aufgabe relevanten Tools bereit und beschreibe sie knapp und präzise.
  • Behalte Beispiele und Stilvorgaben bei, wenn sie eine Produktanforderung vermitteln oder einen bei der Evaluierung festgestellten Mangel beheben.
  • Behalte den Umfang des Kontexts zu Beginn eines Durchlaufs und im weiteren Gesprächsverlauf im Blick. In langen Sitzungen fallen wiederholte Prompt-Inhalte und Tool-Beschreibungen stärker ins Gewicht.

Handlungsspielraum und Genehmigungen festlegen

GPT-5.6 kann mehrstufige Aufgaben eigenständig und ausdauernd bearbeiten. Lege fest, zu welchen Aktionen die jeweilige Anfrage berechtigt. So kann das Modell sichere Arbeiten im vereinbarten Rahmen ohne unnötige Unterbrechungen fortsetzen und rechtzeitig anhalten, bevor es externe, destruktive oder kostspielige Aktionen ausführt oder den Aufgabenbereich erweitert.

In der Regel genügen wenige klare Regeln:

Wenn du eine Frage beantworten, etwas erklären oder überprüfen, eine Diagnose stellen
oder einen Plan erstellen sollst, prüfe das relevante Material und teile das Ergebnis mit.
Nimm Änderungen nur vor, wenn die Anfrage auch dazu auffordert.

Wenn du etwas ändern, entwickeln oder reparieren sollst, nimm die angeforderten lokalen
Änderungen im Rahmen der Aufgabe vor und führe die dafür relevanten, nicht destruktiven
Prüfungen durch. Für diese Schritte brauchst du nicht vorher nachzufragen.

Hole eine Bestätigung ein, bevor du in externe Systeme schreibst, destruktive Aktionen
ausführst, Käufe tätigst oder den Umfang der Aufgabe wesentlich erweiterst.

Benenne sichere lokale Aktionen ausdrücklich, etwa das Lesen von Dateien, das Prüfen von Logs, das Bearbeiten von Code im vereinbarten Rahmen und das Ausführen von Tests. Halte die Regeln an einer Stelle fest und formuliere jede Regel nur einmal. Wiederholte Anweisungen wie „Frage zuerst nach“, „Nimm keine Änderungen vor“ oder „Warte auf die Genehmigung“ können dazu führen, dass das Modell auch bei sicheren, erwarteten Aktionen unnötig eine Genehmigung anfordert.

Länge und Stil der Antworten festlegen

GPT-5.6 antwortet standardmäßig meist knapper als GPT-5.5. Prüfe beim Umstieg, ob allgemeine Anweisungen wie „Antworte knapp“ oder „Halte dich kurz“ weiterhin sinnvoll sind. Bei manchen Aufgaben sind sie überflüssig und können zu allzu kurzen Antworten führen. Behalte sie bei, wenn sie zuverlässig die Ausgabe liefern, die deine Anwendung braucht.

Für einen einheitlichen Detailgrad über mehrere Anfragen hinweg lege mit text.verbosity einen Standardwert fest. Beschreibe die Anforderungen der jeweiligen Aufgabe im Prompt.

Mit text.verbosity einen Standardwert festlegen

Wähle low, medium oder high als standardmäßigen Detailgrad für eine Anfrage. Gib im Prompt an, welche Länge, Struktur oder Inhalte die Aufgabe erfordert. Ein API-Beispiel findest du im Abschnitt text.verbosity konfigurieren.

Festlegen, was eine kurze Antwort enthalten muss

Wenn eine Aufgabe eine kürzere Antwort verlangt, gib an, welche Informationen das Modell beibehalten muss und welche Details es weglassen kann. Zum Beispiel:

Beginne mit der Schlussfolgerung. Nenne die Belege, die sie stützen, alle wesentlichen
Einschränkungen und den nächsten Schritt. Lass nebensächliche Details und Wiederholungen weg.

Behalte alle erforderlichen Fakten, Entscheidungen, Einschränkungen und nächsten Schritte bei.
Kürze zuerst Einleitungen, Wiederholungen, pauschale Beschwichtigungen und entbehrliche
Hintergrundinformationen.

Damit kennt das Modell die Reihenfolge der Prioritäten. Es behält zunächst die Inhalte bei, die zur Erfüllung der Aufgabe nötig sind, und kürzt dann weniger wichtige Details.

Ton festlegen

Allgemeine Vorgaben wie „freundlich“ oder „einfühlsam“ lassen Interpretationsspielraum. Beschreibe konkret, was den Ton deines Produkts ausmacht. Dazu gehört, wie direkt das Modell antworten soll, wann es auf ein gemeldetes Problem eingehen soll und ob ein beruhigender Hinweis oder eine Grußformel angemessen ist.

Antworte direkt. Wenn jemand ein Problem meldet, gehe auf das konkrete Problem ein,
bevor du den nächsten Schritt nennst. Gib nur dann einen beruhigenden Hinweis,
wenn er zur Situation passt. Verzichte auf pauschales Lob und unnötige Grußformeln.

Pro-Modus

Pro-Modus wählen, wenn Qualität Vorrang hat

Der Pro-Modus ist ein Ausführungsmodus der Responses API. Das Modell investiert mehr Rechenarbeit in eine Anfrage und gibt anschließend eine einzige abschließende Antwort zurück. Das kann bei schwierigen Aufgaben die Zuverlässigkeit verbessern, erhöht aber die Latenz. Die dabei verbrauchten Token fließen in den ausgewiesenen Gesamtverbrauch ein. Für diese Token gelten die regulären Token-Preise des gewählten Modells.

Nutze den Pro-Modus, wenn schon ein kleiner Qualitätsgewinn für das Ergebnis entscheidend ist und die Aufgabe schwierig genug ist, um davon zu profitieren. Beispiele sind komplexe Optimierungsprobleme, die Entwicklung oder Prüfung von Code, bei dem viel auf dem Spiel steht, und eingehende Analysen mit klaren Bewertungskriterien. Verwende vorzugsweise den Standardmodus für Routineaufgaben, bei hohem Anfragevolumen oder wenn geringe Latenz wichtig ist. Das gilt auch, wenn deine Evaluierungen keinen nennenswerten Vorteil des Pro-Modus zeigen.

Reasoning-Modus und Reasoning-Aufwand sind voneinander unabhängig. Der Pro-Modus funktioniert mit jedem GPT-5.6-Modell und allen vom jeweiligen Modell unterstützten Stufen des Reasoning-Aufwands. Beginne mit dem Modell und dem Reasoning-Aufwand, die dir im Standardmodus als Referenz dienen. Vergleiche die Konfigurationen dann anhand repräsentativer Aufgaben. Der höchste Aufwand bietet nicht zwangsläufig das beste Verhältnis von Qualität, Latenz und Kosten.

Pro-Modus in der API konfigurieren

Aktiviere den Pro-Modus in der API-Anfrage. Verwende denselben ergebnisorientierten Prompt wie im Standardmodus. Nenne das Ziel, den relevanten Kontext, die Vorgaben, die erforderlichen Belege, die Erfolgskriterien und das Ausgabeformat. Du musst das Modell weder auffordern, „den Pro-Modus zu verwenden“ oder „gründlicher nachzudenken“, noch mehrere Antwortvarianten anfordern.

Zum Beispiel:

Prüfe diesen Plan für eine Datenbankmigration auf mögliche Fehler, die zu Datenverlust
oder längeren Ausfallzeiten führen könnten. Nenne für jeden Befund den betreffenden
Schritt im Plan, schätze die Auswirkungen und die Eintrittswahrscheinlichkeit ein und
empfiehl eine konkrete Gegenmaßnahme. Liste die fünf wichtigsten Risiken nach Schweregrad
geordnet auf. Beginne mit dem schwerwiegendsten.

Qualität und Kosten vergleichen

Vergleiche Standard- und Pro-Modus anhand derselben repräsentativen Aufgaben. Prüfe, ob die Aufgabe erfolgreich gelöst wurde, die Antwort vollständig ist und die erforderlichen Belege vorliegen. Erfasse außerdem den gesamten Token-Verbrauch, die Latenz und die Kosten. Setze den Pro-Modus gezielt dort ein, wo der Gewinn an Qualität oder Zuverlässigkeit die zusätzliche Rechenarbeit rechtfertigt.

Mehr dazu erfährst du im Leitfaden zum Reasoning-Modus.

Programmgesteuerte Tool-Aufrufe

Je nach Aufgabe programmgesteuerte Tool-Aufrufe wählen

Programmgesteuerte Tool-Aufrufe (PTC) eignen sich am besten für klar abgegrenzte Workflows, bei denen Code mehrere Tool-Ergebnisse oder umfangreiche Zwischenausgaben verarbeiten und ein deutlich kleineres, strukturiertes Ergebnis zurückgeben kann. Nutze sie zum Filtern, Verknüpfen, Sortieren nach Rang, Entfernen von Duplikaten, Aggregieren, Validieren oder für andere vorhersehbare Verarbeitungsschritte.

Allein die Tatsache, dass mehrere Aufrufe nötig sind, parallel laufen oder voneinander abhängen, ist noch kein Grund für programmgesteuerte Tool-Aufrufe. Bevorzuge direkte Tool-Aufrufe ohne PTC in folgenden Fällen:

  • Ein einziger Aufruf reicht aus.
  • Die Zwischenergebnisse sind bereits klein.
  • Jedes Ergebnis kann die nächste Entscheidung des Modells beeinflussen.
  • Eine Aktion erfordert eine Genehmigung.
  • Die endgültige Ausgabe muss Quellenverweise oder Artefakte im ursprünglichen Format enthalten.

Die Aufrufart für jede Aufgabe vorgeben

Verlass dich bei der Wahl der Aufrufart nicht allein auf die verfügbaren Tools oder auf allgemeine Anweisungen wie „Nutze programmgesteuerte Tool-Aufrufe effizient“. Wenn sowohl direkte als auch programmgesteuerte Aufrufe möglich sind, lege ausdrücklich fest:

  • In welchem klar abgegrenzten Arbeitsschritt das Modell programmgesteuerte Tool-Aufrufe verwenden soll.
  • Welche Tools es dabei aufrufen darf.
  • Welchem Schema die Ausgabe genau entsprechen muss und welche Belege sie enthalten soll.
  • Wie viele Aufrufe parallel laufen dürfen, wie oft das Modell einen Aufruf wiederholen darf und wann es anhalten muss.
  • Für welche Arbeitsschritte das Modell weiterhin direkte Aufrufe verwenden soll.

Beschreibe für jedes Tool die erwarteten Rückgabefelder, ihre Datentypen und das Verhalten im Fehlerfall. Wenn das Modell vor dem Schreiben des Programms nicht erkennen kann, wie die Rückgabe aufgebaut ist, bevorzuge direkte Tool-Aufrufe. So kann das Modell das Ergebnis prüfen, bevor es entscheidet, wie es dieses verwendet.

Wenn beide Aufrufarten nötig sind, lege einen eindeutigen Übergabepunkt fest. Weise das Modell an, die Aufrufart darüber hinaus nicht zu wechseln und abgeschlossene Arbeit nicht zu wiederholen.

Zum Beispiel:

<tool_orchestration>
Verwende für [bounded stage] programmgesteuerte Tool-Aufrufe. Rufe dabei ausschließlich
[eligible tools] auf. Führe unabhängige Aufrufe parallel aus, wenn das sicher ist.
Verwende nur dokumentierte Ein- und Ausgabefelder der Tools.

Verarbeite und verdichte die Zwischenergebnisse. Gib das Ergebnis genau nach dem Schema
[output schema] aus und füge die Belege bei, die für die abschließende Antwort nötig sind.

Beende die Verarbeitung, sobald [condition] erfüllt ist. Wiederhole einen Aufruf bei
vorübergehenden Fehlern höchstens [R] Mal. Wiederhole keine abgeschlossenen Aufrufe und
führe keine Aktionen mit Seiteneffekten aus. Fehlt weiterhin ein erforderliches Ergebnis,
gib eine eindeutige, strukturierte Fehlermeldung zurück.

Verwende direkte Tool-Aufrufe für [semantic judgment, approval, or final validation].
</tool_orchestration>

Abschließende Antwort prüfen

Das Element program_output und die abschließende message des Assistenten sind separate Ausgaben. Teste beide. Ein Programm kann die richtigen Datensätze zurückgeben, obwohl in der Nachricht ein Pflichtfeld, ein Quellenverweis oder ein wichtiger Vorbehalt fehlt.

Vergleiche direkte und programmgesteuerte Aufrufe anhand derselben repräsentativen Aufgaben. Prüfe, ob die abschließende Antwort korrekt und vollständig ist und die erforderlichen Belege enthält. Vergleiche anschließend den gesamten Token-Verbrauch, die Latenz, die Kosten und die Anzahl der Aufrufe, Gesprächsrunden und Wiederholungsversuche. Werte einen geringeren Ressourcenverbrauch nur dann als Verbesserung, wenn die Antwort deine bestehenden Evaluierungen weiterhin besteht.

Mehr dazu erfährst du im Leitfaden zu programmgesteuerten Tool-Aufrufen.