AI-Entwicklung

OpenAI DevDay 2026: Prognose zu Structured Outputs, Function Calling und AI Agents

JSONSort Veröffentlicht 2026-09-02 Aktualisiert 2026-09-02 Ca. 14 Min.

OpenAI DevDay 2026 findet am 29. September in Fort Mason, San Francisco statt. Die Keynote wird gestreamt; Fachsessions behandeln APIs, Agents und Produktionsmuster. Produktnamen stehen noch unter Embargo, die Schichten sind klar: Structured Outputs liefern gültiges JSON, Function Calling drückt Aufrufabsicht aus, AI Agents fügen beides zu einem lauffähigen Ablauf. Der Beitrag prognostiziert diese drei Schichten anhand der öffentlichen API-Linie seit 2025 und die JSON-Schema-Arbeit vor der Keynote.

Kurzüberblick

Schicht	Stand 2026-09	Wahrscheinliche DevDay-Richtung
Structured Outputs	`json_schema` + `strict` erzwingt Schema-Passung	reicherer Schema-Teil, inkrementell gültige Streams, Standard bei Handoffs
Function Calling	`tools[]` / `tool_calls`; `arguments` bleibt Zeichenkette	native JSON-Argumente, parallele + serielle Pläne, MCP-Abbildung erster Klasse
AI Agent	Responses API + Agents SDK; Assistants API am 26. August eingestellt	typisierte Handoffs, beobachtbare JSON-Traces, MCP-/A2A-Zusammenspiel

Prognosen aus dem öffentlichen API-Pfad – keine offizielle Agenda und kein Leak. Die Keynote am 29. September gilt.

Wann DevDay 2026 stattfindet und was wir prognostizieren

Das Datum steht: 29. September 2026, Fort Mason, San Francisco, ein Tag. Die Keynote ist frei im Stream; weitere Sessions erscheinen danach auf openai.com. Vor-Ort-Bewerbungen endeten am 10. Juli; Einladungskarten kosteten 650 Dollar. Erstmals folgen DevDay Exchanges: Bengaluru 16. Oktober, Tokio 20., Seoul 22., Berlin 26., Paris 28., London 3. November, São Paulo 6., Mexiko-Stadt 11.

Die öffentliche Seite nennt APIs, Agents, Produktionsmuster und Sicherheit. Produktnamen bleiben gesperrt. Dieser Text macht nur widerlegbare Prognosen – jede trifft einen aktuellen Schmerz und lässt sich nach der Keynote bewerten. Keine Gerüchte zu Modellgröße oder Hardware, nur das JSON, das Entwickler täglich schreiben.

Die Drei-Schichten-Basis im September 2026

Zuerst klären, was schon ausgeliefert ist, damit vorjährige Funktionen nicht als diesjährige Premiere gelten.

Structured Outputs (seit August 2024): strenger als JSON-Modus – die Ausgabe muss zum JSON Schema passen. In der Responses API über text.format, bei Werkzeugen über strict: true.
Function Calling: tools[] injizieren, tool_calls empfangen. arguments ist weiter stringifiziertes JSON; der Host parst und prüft.
AI Agents: Produktion läuft über Responses API + Agents SDK. AgentKit von DevDay 2025 (Agent Builder, ChatKit, Connector Registry) bleibt die Orchestrierungsschicht. Die Assistants API endete am 26. August 2026.

Daneben liegen zwei Ökosystemschichten: Werkzeugversorgung in MCP Tool Schema vs Function Calling, Agent-Interop in A2A Extensions. DevDay ersetzt diese offenen Protokolle kaum; wahrscheinlicher ist der Anschluss an den OpenAI-Aufrufrahmen.

Prognose 1: Structured Outputs werden Standardrohr, nicht Option

Structured Outputs stoppen bereits „sieht aus wie JSON, passt nicht zum Schema“. Reibung bleibt: schmales Schema-Teilset, ungültige Streams mitten im Token, instabile Ablehnungsformen. Der wahrscheinliche DevDay-Schritt: Schema wird Standardvertrag in Agent-Pipelines.

Ein Ticket-Extraktionsschema sieht so aus:

{
  "name": "ticket_extract",
  "strict": true,
  "schema": {
    "type": "object",
    "properties": {
      "priority": { "type": "string", "enum": ["low", "medium", "high"] },
      "assignee": { "type": "string" },
      "summary": { "type": "string" },
      "labels": { "type": "array", "items": { "type": "string" } }
    },
    "required": ["priority", "summary"],
    "additionalProperties": false
  }
}

Erwartete Änderungen, von wahrscheinlich nach weniger wahrscheinlich:

Reicherer JSON-Schema-Teil. oneOf, $ref und begrenzte Rekursion brechen oft. Exklusive Zweige wie Erstattung | Umtausch | Mensch brauchen oneOf statt flachem Enum.
Streams bleiben inkrementell gültig. Oberflächen, die Tabellen tokenweise zeichnen, sterben an halb geschlossenem JSON. Besser: jedes geschlossene Feld ist sofort prüfbar.
Ablehnung und Fehler bleiben im Schema. Sicherheitsablehnungen verlassen oft die Objektform. Produktion braucht refusal als gültiges JSON, nicht Freitext.
Ein Schema über eine Modellfamilie. Teams wechseln schon GPT-5-Snapshots; „ein Schema, viele Snapshots“ reduziert Adaptercode.

Klammern in JSONSort-Formatierung prüfen, dann required / additionalProperties mit dem JSON-Schema-Tutorial abgleichen. Modellausgaben mit Nutzerdaten nicht auf öffentliche JSON-Seiten laden.

Prognose 2: Function Calling wird Plan, nicht Einzelaufruf

Function Calling wuchs von einer Funktion zu parallelen tool_calls. Der Engpass 2026 ist nicht mehr „ruft es ein Werkzeug?“, sondern falsche Wahl bei vielen Werkzeugen, doppelt kodierte Argumente, untypisierte Ergebnisse und handgeschriebene MCP-Abbildungen. DevDay liefert eher Aufrufpläne und typisierte Hin-und-Rückwege als einen weiteren Alias für tools.

Eine aktuelle Werkzeugdefinition sieht noch so aus:

{
  "type": "function",
  "function": {
    "name": "create_ticket",
    "strict": true,
    "parameters": {
      "type": "object",
      "properties": {
        "title": { "type": "string" },
        "priority": { "type": "string", "enum": ["low", "medium", "high"] }
      },
      "required": ["title", "priority"],
      "additionalProperties": false
    }
  }
}

Die relevanten Prognosen:

arguments als natives JSON-Objekt (oder Objekt plus Zeichenkette). Ein zweites JSON.parse ist ein häufiger Produktionsfehler; die Responses API kann das festziehen.
Parallele + serielle Pläne als Erste-Klasse. Parallelaufrufe gibt es; „erst Bestellung, dann Erstattung“ lebt in Prompts oder eigener Zustandsmaschine. Ein Feld im Stil depends_on spart eine Orchestrierungsschicht.
MCP-Werkzeuge erscheinen direkt in tools[]. Hosts schreiben inputSchema → parameters nicht mehr um. Das passt zum früheren Fazit: MCP liefert, die API-Schicht ausdrückt Absicht.
Werkzeugergebnisse nutzen ebenfalls Structured Outputs. role: tool ist meist Freitext; schema-passende Ergebnisse kann ein nachgelagerter Agent verarbeiten.
Werkzeugsuche statt 50 Einträge auf einmal. Große Schemas sind teuer und erhöhen Fehlaufrufe. Wahrscheinlicher: Kurzliste holen, dann dem Modell geben.
strict: true wird Standard. Neue Integrationen müssen kein Flag merken.

Prognose 3: Agents behandeln JSON-Verträge als Laufzeit, nicht als Konfiguration

Der Agent-Pfad 2025–2026: Assistants verlassen, Agents, Werkzeuge, Handoffs und Guardrails als Code im Agents SDK schreiben. AgentKit liefert weiter Leinwand, Chat-UI und Konnektoren. Branchenberichte nennen einen möglichen Exportstopp des visuellen Agent Builders nach dem 30. November – gegen offizielle Hinweise prüfen. Die Richtung ist klar: versionsfähige Code-Orchestrierung schlägt eine nicht exportierbare Leinwand.

Was DevDay betonen dürfte, ist kein weiterer Chatbot, sondern typisierte Handoffs:

{
  "handoff": {
    "from": "triage",
    "to": "billing_agent",
    "output": {
      "intent": "refund",
      "order_id": "A-1042",
      "confidence": 0.91
    }
  }
}

Ist dieses JSON ein SDK-Objekt erster Klasse, hängt Routing nicht mehr daran, dass das Modell „billing“ im Fließtext nennt. Begleitprognosen:

Handoffs verlangen output_type. Ein Triage-Agent gibt ein Klassifikationsobjekt aus und übergibt. Das ist Structured Outputs.
Traces und Evals sind JSON. Bewertungen, Schrittspuren und Regressionsmengen werden dateidiff-fähig, keine Konsolenfotos.
MCP und A2A liegen in derselben Pipeline. MCP-Server liefern Werkzeuge; A2A verteilt Aufgaben mit Erweiterungsköpfen. OpenAI vertieft eher ein Konnektorregister, als ein drittes Interop-Protokoll zu erfinden.
Lange Jobs setzen an strukturierten Prüfpunkten fort. Computer Use und Nachtläufe brauchen wiederherstellbaren JSON-Zustand, nicht nur Chatverlauf.

Wie die drei Schichten ein JSON-Rohr werden

Gestapelt ist die konservative Architektur Ende 2026 Schichten, kein Entweder-oder:

JSON Schema ist die einzige Quelle der Wahrheit. schemas/tools/*.json und schemas/handoffs/*.json ins Git.
Structured Outputs begrenzen das Objekt an Nutzer oder nachgelagerten Agent.
Function Calling begrenzt Aufrufabsicht zu externen Systemen; Parameter-Schemas kommen aus denselben Dateien.
Die Agent-Laufzeit routet über Handoff-JSON, führt über Tool-JSON aus, prüft über Trace-JSON.
MCP / A2A regeln Versorgung über Hosts und Verhandlung zwischen Agents. Sie ersetzen die drei Schichten nicht.

Bei Drift JSON Diff zwischen dem Schema der letzten Woche und dem, das das Modell heute ablehnt. Viele „das Modell wurde schlechter“-Fälle sind ein zusätzliches required-Feld.

Was jetzt vorbereiten (nicht bis zum 29. September warten)

Werkzeugparameter, Handoff-Objekte und Eval-Fixtures als JSON Schema schreiben – nicht als Prosa im Prompt.
Neuer Code nur über Responses API / Agents SDK. Keine Assistants-Threads mehr öffnen.
Pro Werkzeug strict: true und Beispiel-Payloads in CI prüfen (ajv oder vergleichbar).
Ab zehn Werkzeugen Routing oder Suche. Den ganzen Katalog nicht in eine Anfrage kippen.
arguments als Zeichenkette oder Objekt parsen, damit ein Typwechsel nach DevDay nicht die ganze Seite umlegt.
Geheime oder nutzerbezogene Tool-Antworten nur lokal: formatieren, diffen, kein Upload.

Häufige Fallstricke

Eine Prognose wie eine Freigabemeldung lesen. Bis zum 29. September Zweitquellen zu „OpenAI liefert X“ abwerten. Jede Behauptung hier kann auf der Bühne scheitern.
Structured Outputs und Function Calling zu einem Schalter machen. Eines formt die Aussage an Nutzer oder Folge-Agent, das andere den Aufruf. Agents schalten oft beides ein.
Annehmen, MCP sterbe am DevDay. Tiefere Konnektoren sind wahrscheinlicher als ein neues inputSchema.
Leinwand-Abläufe ohne Export. Wer noch einen visuellen Builder nutzt, exportiert Knoten, Prompts und Schemas zuerst nach Git.
Doppelt kodierte arguments ignorieren. Bis native Objekte kommen, bleibt das der häufigste Produktionsfehler.

FAQ

Ist das die offizielle Agenda?

Nein. Datum, Ort und Themenfelder stammen von der öffentlichen Eventseite. Produktdetails sind eine Prognose aus aktuellen API-Schmerzen. Primärquelle ist die gestreamte Keynote.

Ersetzen Structured Outputs Function Calling?

Nein. Structured Outputs formen das Endobjekt, Function Calling die Werkzeugaufrufe. Das Muster 2026 ist Stapeln: dasselbe Schema deckt Parameter und Handoffs.

Assistants ist weg – was passiert mit alten Threads?

Produktion auf Responses API + Agents SDK legen. Threadzustand, Werkzeugdefinitionen und Ausgabeschemas zuerst exportieren, dann Orchestrierung im SDK neu schreiben. Nicht auf automatische Leinwand-Übersetzung warten.

Kein Ticket – wie mitverfolgen?

Die Keynote ist frei; Sessions erscheinen danach. Bewerbungen für Exchange-Städte laufen bis 17. September. Für die meisten Teams schlagen Nachdokumente eine Flurfrage.

Wie debugge ich Werkzeug- und Handoff-JSON?

Im Browser mit JSONSort formatieren, prüfen und diffen. Tool-Antworten mit Geheimnissen nicht auf öffentliche JSON-Seiten kleben.

Fazit

DevDay 2026 erfindet kaum ein weiteres „JSON-förmiges“ Format. Wahrscheinlicher: Structured Outputs werden Standardvertrag, Function Calling wird Plan mit Abhängigkeiten, die Agent-Laufzeit wird eine JSON-Zustandsmaschine, die sich diffen lässt – tiefer an MCP und A2A angebunden. Der Hebel vor der Show ist nicht das Erraten von Produktnamen, sondern Schemas als einzige Wahrheit im Git. Die Keynote am 29. September bewerten, Passendes behalten, Rest verwerfen. Die JSON-Vorbereitung bleibt wertvoll.

Weiterlesen

OpenAI Structured Outputs Aktuelle Nutzung von json_schema und strict
OpenAI Function Calling Form von tools / tool_calls
MCP Tool Schema vs Function Calling Protokollgrenze für Werkzeug-JSON
A2A Extensions und das JSON-Protokoll Dritte Schicht der Multi-Agent-Interop
JSONSort lokaler Werkzeugkasten Formatieren, prüfen, Diff
Alle Beiträge Weitere Notizen zu JSON und AI-Entwicklung

Änderung: 2026-09-02 Erstfassung (Prognose vor DevDay)