GPT-5.6: Das Modell schreibt Orchestrierungscode für programmatische Tool-Aufrufe

Klassische Funktionsaufrufe haben eine Form, die jeder Agent-Entwickler auswendig kennt. Das Modell fordert einen Tool-Aufruf an, Ihre Anwendung führt ihn aus, Sie fügen das Ergebnis hinzu, und das Modell fordert den nächsten an. Vier Tools, vier Roundtrips. Vierzig Tools, vierzig. Jeder Durchlauf erhöht die Netzwerklatenz und den neu berechneten Kontext. Als OpenAI am 9. Juli 2026 GPT-5.6 zur allgemeinen Verfügbarkeit freigab, lieferte es einen Weg von diesem "Hamsterrad" weg: programmatische Tool-Aufrufe in der Responses API.

Die Idee ist direkt. Anstatt Tool-Aufrufe einzeln zurückzugeben, damit Ihr Code sie in einer Schleife ausführt, schreibt das Modell JavaScript, das mehrere Tool-Aufrufe selbst orchestriert. Dieser Code wird in einer isolierten V8-Laufzeitumgebung ohne Netzwerkzugriff ausgeführt. Ihre Tools bleiben der einzige Weg, wie der Code die Außenwelt berühren kann, sodass die Sicherheitsgrenze, über die Sie sich bereits bei OpenAI-Funktionsaufrufen Gedanken machen, genau dort bleibt, wo sie war. Was sich verschiebt, ist die Orchestrierung: die Schleifen, Bedingungen und Aggregation, die früher in Ihrer Anwendung stattfanden.

Die Umstellung wirkt sich auch auf Ihre Seite der API aus. Jedes Tool, das Sie freigeben, ist jetzt ein Vertrag, den das Modell in Dutzenden von Aufrufen auf einmal statt eines sorgfältigen Aufrufs pro Runde ausführen kann. Die Präzision des Schemas, die Fehlerstrukturen und das Ratenverhalten sind wichtiger als noch letzte Woche. Dieser Artikel behandelt, was ausgeliefert wurde, warum die alte Schleife Nachteile hat, was gleich bleibt und wie Sie Ihre Tool-Endpunkte mit Apidog vorbereiten, bevor Sie sie dem Modell übergeben.

TL;DR

• GPT-5.6 wurde am 9. Juli 2026 allgemein verfügbar (GA). Bei der GA erhielt die Responses API die programmatische Tool-Aufrufmöglichkeit, bestätigt in den Entwicklerdokumenten von OpenAI.
• Anstatt eines Tool-Aufrufs pro Roundtrip, schreibt das Modell JavaScript, das Schleifen, Bedingungen und Aggregation über Ihre Tools komponiert.
• Der generierte Code läuft in einer isolierten V8-Sandbox ohne Netzwerkzugriff. Ihre Tool-Definitionen bleiben der einzige Weg zu externen Systemen, sodass die Sicherheitsgrenze sich nicht verschiebt.
• Latenz und Token-Kosten summieren sich nicht mehr mit der Anzahl der Tool-Aufrufe, was der Schwachpunkt klassischer Agenten-Schleifen ist.
• Die Funktion ist erst wenige Tage alt; genaue Anforderungsparameter und Limits finden Sie in der OpenAI-API-Referenz, also lesen Sie diese, bevor Sie entwickeln.
• Testen und simulieren Sie jeden Tool-Endpunkt, bevor das Modell ihn orchestriert; eine Schema-Mehrdeutigkeit wird zu einem Fehler, der in einer Schleife wiederholt wird.

Was am 9. Juli ausgeliefert wurde

GPT-5.6 wurde als dreistufige Familie eingeführt: gpt-5.6-sol für tiefste Schlussfolgerungen, gpt-5.6-terra für ausgewogene Aufgaben und gpt-5.6-luna für schnelles, kosteneffizientes Volumen. Der einfache Alias gpt-5.6 leitet zu Sol weiter. Alle drei sind über die API selbstständig nutzbar, ohne Plan-Beschränkungen, nach einer zweiwöchigen limitierten Vorschau, die am 8. Juli endete, als die Zugangsbeschränkung aufgehoben wurde.

Die Modellfamilie erhielt den größten Teil der Aufmerksamkeit am Starttag, aber die neue API-Oberfläche ist die größere Geschichte für Agentenentwickler. Gemäß MarkTechPosts Berichterstattung zum Start und OpenAIs eigener Dokumentation hat die Responses API bei der GA vier Neuerungen erhalten: programmatische Tool-Aufrufe, eine Multi-Agenten-Beta, persistentes Reasoning über mehrere Runden hinweg und Vision-Detail-Einstellungen, die die ursprünglichen Bilddimensionen erhalten.

Programmatische Tool-Aufrufe sind die Schlagzeile. OpenAI beschreibt es so, dass das Modell JavaScript schreibt, um Tool-Aufrufe zu orchestrieren, die in einer isolierten V8-Laufzeitumgebung ohne Netzwerkzugriff ausgeführt werden. Das Modell ist nicht mehr ein rundenbasierter Anfragender, sondern wird zum Autor der Orchestrierungsebene.

Die Schleife, die programmatische Tool-Aufrufe ersetzen

Hier ist der klassische Funktionsaufruf gegen die Responses API, die Form, die fast jeder Produktionsagent heute verwendet:

import OpenAI from "openai";
const client = new OpenAI();

const tools = [
  {
    type: "function",
    name: "get_flight_status",
    description: "Return live status for a flight by IATA flight number.",
    parameters: {
      type: "object",
      properties: {
        flight_number: {
          type: "string",
          description: "IATA flight number, for example SQ317"
        }
      },
      required: ["flight_number"]
    }
  }
];

let response = await client.responses.create({
  model: "gpt-5.6",
  input: "Which of these 12 flights are delayed: SQ317, BA15, UA857...",
  tools
});

Das Modell kann ohne Daten nicht antworten, daher gibt es einen Funktionsaufruf aus. Ihr Code führt die Abfrage aus, fügt ein function_call_output-Element an und ruft die API erneut auf:

// Ein Roundtrip pro Tool-Aufruf. Diese Schleife ist der Preis.
while (hasFunctionCalls(response)) {
  const outputs = await executeToolCalls(response); // Ihr Code, Ihre Infrastruktur
  response = await client.responses.create({
    model: "gpt-5.6",
    previous_response_id: response.id,
    input: outputs,
    tools
  });
}

Für 12 Flüge kann diese Schleife 12 Mal ausgeführt werden, und jede Iteration zahlt doppelt. Zuerst in der Latenz: ein vollständiger Netzwerk-Roundtrip zu OpenAI plus Modellzeit, serialisiert, weil Aufruf N+1 vom Modell abhängt, das Ergebnis N zu sehen. Zweitens in Tokens: Tool-Ergebnisse sammeln sich im Kontext an, sodass spätere Iterationen alles neu verarbeiten, was die früheren erzeugt haben. Verkettete Agenten führen zu einer unschönen Kumulation: Ein Fünf-Schritte-Agent, bei dem jeder Schritt eine Zehn-Aufruf-Schleife umschließt, bedeutet fünfzig abgerechnete Modellaufrufe.

Keine dieser Schleifen ist Intelligenz. Es ist Klempnerarbeit, und bis diese Woche hatte das Modell keine Möglichkeit, diese Klempnerarbeit selbst zu schreiben.

Wie der programmatische Modus die Form ändert

Mit programmatischen Tool-Aufrufen beantwortet das Modell die Flugfrage anders: Es schreibt ein kurzes JavaScript-Programm, das die zwölf Flugnummern durchläuft, für jede get_flight_status aufruft, nach verspätetem Status filtert, nach Verspätungsdauer sortiert und das Aggregat zurückgibt. Die Sandbox führt dieses Programm aus. Ihre Tools leisten weiterhin die eigentliche Arbeit; der Kontrollfluss um sie herum gehört nun dem Modell.

Drei Eigenschaften machen dies praktikabel und nicht alarmierend:

• Die Laufzeitumgebung ist isoliert. OpenAI führt das generierte JavaScript in einer V8-Sandbox ohne Netzwerkzugriff aus. Der Code kann keine URL abrufen, keinen Socket öffnen oder eigenständig Daten exfiltrieren.
• Tools sind der einzige Ausweg. Jeder externe Effekt wird über die von Ihnen definierte Tool-Oberfläche geleitet. Wenn Sie kein delete_record-Tool freigegeben haben, kann kein generierter Code einen Datensatz löschen.
• Der Kontrollfluss wird ausdrucksstärker. Schleifen, Bedingungen, vorzeitige Beendigungen, Aggregation über Ergebnisse hinweg: Muster, die N Roundtrips erforderten, geschehen jetzt innerhalb eines einzigen Antwortzyklus.

Was gleich bleibt

Sie definieren Tools immer noch mit Namen, Beschreibungen und JSON-Schema-Parametern, genau wie im obigen Code. Das Modell kann nur Aufrufe an Tools zusammensetzen, die Sie deklariert haben, was bedeutet, dass die Frage „Was kann dieser Agent mit meinen Systemen anstellen?“ dieselbe Antwort hat wie zuvor: alles, was Ihre Tool-Oberfläche zulässt, und nichts anderes.

Die Schemaqualität ist jetzt wichtiger, nicht weniger. In der klassischen Schleife führte eine vage Parameterbeschreibung zu einem fehlerhaften Aufruf, den Sie vor dem nächsten Roundtrip abfangen und korrigieren konnten. Im programmatischen Modus kann dieselbe Vagheit in eine Schleife eingebettet und über jede Iteration hinweg wiederholt werden, bevor Sie ein einziges Ergebnis sehen. Die Gewohnheiten, die Sie für strukturierte Ausgaben entwickelt haben, übertragen sich direkt: strikte Typen, Enums für geschlossene Mengen, Beschreibungen, die Einheiten und Formate angeben, ehrlich erforderliche Felder.

Grenzen und offene Fragen

Diese Funktion ist erst wenige Tage alt. Einige Vorsichtsmaßnahmen, bevor Sie Ihren Agenten-Stack darum herum neu aufbauen:

• Die genauen Anforderungsparameter, Ausführungslimits und das Timeout-Verhalten gehören zur API-Referenz und dem Modell-Handbuch von OpenAI. Parameternamen können sich während der Verfeinerungsphase nach einer GA-Veröffentlichung ändern, lesen Sie daher die Referenz, bevor Sie Code für die Funktion schreiben.
• Debugging ist eine neue Oberfläche. Als die Orchestrierung in Ihrem Repository stattfand, konnten Sie einen Breakpoint setzen; jetzt wird ein Teil des Kontrollflusses pro Anfrage neu generiert. Das Protokollieren der Tool-Aufruf-Sequenz, die die Sandbox erstellt, wird zu einer zentralen Beobachtungsaufgabe.
• Es gibt noch keine Produktionserfahrung. Simon Willisons Notizen vom ersten Tag zu GPT-5.6 sind ein guter laufender Überblick darüber, was unabhängige Tests zutage fördern; erwarten Sie, dass dort scharfe Kanten auftauchen, bevor offizielle Dokumente sie erwähnen.
• Eine vernünftige Rollout-Reihenfolge: Beginnen Sie mit schreibgeschützten Tools, beobachten Sie die generierte Orchestrierung, überprüfen Sie die Token-Abrechnung mit Ihrer alten Schleife und geben Sie erst dann Tools mit Nebenwirkungen frei.

Ihre Tools sind jetzt eine API, die der Code eines anderen aufruft

Bei klassischen Funktionsaufrufen wurde ein Tool einmal pro Roundtrip aufgerufen, wobei eine von Menschen erstellte Schleife Tempo und Reihenfolge bestimmte. Bei programmatischen Tool-Aufrufen ruft generierter Code Ihre Tools in Bursts auf, verzweigt sich basierend auf deren Antworten und aggregiert deren Ausgabe. Jedes Tool ist ein API-Vertrag, der von einem maschinengeschriebenen Client verbraucht wird, den Sie nie überprüfen, bevor er ausgeführt wird.

Das erhöht die Anforderungen an vier Dinge:

• Schema-Präzision. Geben Sie Einheiten, Formate und Bereiche in jeder Parameterbeschreibung an. Ein mehrdeutiges Datumsformat ist nicht länger ein einziger schlechter Aufruf; es ist eine Schleife von ihnen.
• Fehlerstrukturen. Generierter Code wird bei Fehlern verzweigen. Ein Tool, das 200 zurückgibt, aber eine Fehlermeldung in einem String versteckt, wird jede Orchestrierung, die gegen Ihr Schema geschrieben ist, in die Irre führen. Geben Sie ehrliche Statuscodes und strukturierte Fehlerkörper zurück.
• Idempotenz und Ratenverhalten. Zwölf Aufrufe, die früher über eine Minute verteilt ankamen, können jetzt in einem einzigen Burst eintreffen. Wissen Sie, was Ihr Endpunkt unter diesem Muster tut, bevor das Modell es für Sie herausfindet.
• Latenz. Ein Tool, das acht Sekunden dauerte, war einmal pro Runde tolerierbar. Innerhalb einer Zwölf-Iterationen-Schleife definiert es Ihre Antwortzeit.

Hier verdient eine echte API-Workbench ihren Platz. Definieren oder importieren Sie die Spezifikation jedes Tool-Endpunkts, senden Sie Testanfragen dagegen und bestätigen Sie, dass das Antwortschema dem entspricht, was Ihre Tool-Definition verspricht. Gehen Sie dann einen Schritt weiter: Simulieren Sie die Tool-API, damit Sie die Orchestrierung gegen vorhersagbare gefälschte Daten üben können, ohne die Produktion zu berühren. Laden Sie Apidog herunter, und sein integrierter Mock-Server liefert schemaförmige Antworten für jeden von Ihnen definierten Endpunkt, sodass Sie dem Modell eine vollständige Tool-Oberfläche übergeben und beobachten können, wie es orchestriert, bevor Sie einen einzigen echten Datensatz berühren.

Die anderen GA-Funktionen in Kürze

Programmatische Tool-Aufrufe wurden nicht allein ausgeliefert. Zwei angrenzende Erweiterungen der Responses API sind hier von Bedeutung:

• Multi-Agent, in Beta: parallele Subagenten-Ausführung, verwaltet von der API. Frühstadium, eher beobachten als darauf setzen.
• Persistentes Reasoning: Reasoning-Kontext, der über mehrere Runden hinweg über reasoning.context wiederverwendet wird, sodass lange Agenten-Sitzungen nicht bei jeder Runde dieselben Schlussfolgerungen neu ableiten müssen.

Beides ergänzt sich mit programmatischen Tool-Aufrufen: Ein Agent, der seine Schlussfolgerungen über mehrere Runden hinweg beibehält und seine eigene Orchestrierung schreibt, leistet pro Aufgabe weitaus weniger redundante Arbeit.

Programmatische Tool-Aufrufe vs. Ultra-Modus

Der Start brachte auch den Ultra-Modus, und die beiden werden verwechselt, weil beide mehr pro Anfrage leisten. Sie lösen unterschiedliche Engpässe.

Ultra ist eine Multi-Agenten-Einstellung, die standardmäßig vier Agenten parallel ausführt und bewusst mehr Tokens verbraucht, um die tatsächliche Ausführungszeit zu verkürzen; laut OpenAI hebt es Terminal-Bench 2.1 von 88,8 % auf 91,9 %. Es ist in ChatGPT Work auf Pro- und Enterprise-Plänen sowie in Codex ab Plus verfügbar. Programmatische Tool-Aufrufe sind eine API-Funktion, bei der ein Agent seine Tools im Code orchestriert. Ultra parallelisiert das Denken; programmatische Tool-Aufrufe reduzieren die Ausführungs-Roundtrips. Die vollständige Erklärung finden Sie in unserem Artikel über den GPT-5.6 Ultra-Modus, aber kurz gesagt: Wenn Ihr Engpass die Latenz von Tool-Aufrufen ist, möchten Sie programmatische Tool-Aufrufe; wenn es die Bedenkzeit bei schwierigen Problemen ist, möchten Sie Ultra.

FAQ

Muss ich meine bestehenden Tool-Definitionen umschreiben?

Nein. Tools behalten dieselbe JSON-Schema-Form wie im obigen Code gezeigt, und Definitionen, die für klassische Funktionsaufrufe geschrieben wurden, werden übernommen. Die lohnende Arbeit besteht darin, sie zu straffen: Enums hinzufügen, Formate angeben und Beschreibungen spezifisch genug gestalten, damit generierter Code sie nicht falsch interpretieren kann.

Kann das generierte JavaScript das Internet erreichen?

Nein. Der Code läuft in einer isolierten V8-Laufzeitumgebung ohne Netzwerkzugriff, und Ihre deklarierten Tools sind der einzige Weg, etwas außerhalb der Sandbox zu beeinflussen. Das macht Ihre Tool-Oberfläche zum gesamten Risikomodell, also prüfen Sie, welche Tools Sie mit der gleichen Sorgfalt freigeben, die Sie einer öffentlichen API widmen würden.

Welche GPT-5.6-Modelle unterstützen programmatische Tool-Aufrufe?

OpenAI dokumentiert dies als Responses API-Oberfläche für die GPT-5.6-Familie, und alle drei Stufen (gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna) sind für jedes API-Konto selbstständig nutzbar. Überprüfen Sie die API-Referenz für Details auf Stufenebene, bevor Sie sich für eine entscheiden. Für die Schlüsseleinrichtung und eine erste Anforderungsanleitung, siehe wie man die GPT-5.6 API verwendet.

Wie unterscheidet sich das vom Code Interpreter?

Der Code Interpreter führt Code als Lieferobjekt aus: Analyse, Diagramme, Dateitransformationen. Programmatische Tool-Aufrufe generieren Code, dessen einzige Aufgabe es ist, Ihre deklarierten Tools zu koordinieren; das Lieferobjekt sind die aggregierten Tool-Ergebnisse, nicht der Code selbst.

Was das für Sie bedeutet

Die Roundtrip-Schleife war der uninteressanteste Teil jedes von Ihnen ausgelieferten Agenten, und GPT-5.6 hat sie optional gemacht. Die Orchestrierung wanderte zum Modell; die Verantwortung für saubere, präzise, gut funktionierende Tool-APIs wanderte zu Ihnen, mit größerem Gewicht als zuvor.

Der nächste Schritt ist konkret. Wählen Sie einen leseintensiven Workflow, schreiben oder straffen Sie die benötigten Tool-Schemata und führen Sie jeden Endpunkt durch Apidogs API-Client und Mock-Server, bis der Vertrag auch bei Burst-Aufrufen und fehlerhaften Eingaben hält. Wenn das Modell beginnt, Code gegen Ihre Tools zu schreiben, möchten Sie, dass dieser Code von einer Oberfläche liest, die Sie bereits getestet haben.