OpenAI Agents API vs. Responses API: Wie sollten Entwickler 2026 wählen? Tool Calling, Structured Output, Multi-Agent

Auf einen Blick

Tür	Ein Satz	Was Sie halten
Agents API	OpenAI dreht das Codex-Harness	Session / Environment
Responses API	Sie rufen das Modell und drehen die Schleife	input / output items
Agents SDK	Die Schleife bleibt in Ihrem Prozess	runner / handoff
JSON-Kette	Namen, Argumente, Ergebnisse bleiben Objekte	call_id / Schema

Zuerst das Subjekt: wollen Sie die Schleife besitzen? Tür tauschen; die JSON-Aufrufkette bleibt.

Sie wählen, wer die Schleife dreht, nicht wer klüger ist

2026 läuft GPT-6-Astra-Tool-Calling schon über Responses. Agents API ist eine andere Schicht: gehostete Sessions, verdichteter Kontext, Subagents. Dieselbe JSON-Kette. Anderes Subjekt.

• Sie müssen jeden Sprung besitzen — Freigaben, Retries, function_call_output zurückschreiben — Responses API.
• Stundenlange Jobs, gehostete Recovery, Sandbox oder Subagents — Agents API.
• Die Schleife muss in Ihrem Prozess bleiben, Sie wollen aber einen Runner — Agents SDK; darunter oft Responses.

Wie Agents API selbst Tools ruft: OpenAI-Agents-API-Rundgang. Wenn Agent und Function Calling noch ein Wort sind: AI-Agent-Leitfaden.

Jede API besitzt eine Schicht

Responses ist die untere Schicht: /v1/responses. Sie senden input, Sie bekommen typisierte Items: message, reasoning, function_call. GPT-6-Astra-Leitfaden-Tool-Calling verlangt diesen Weg. Structured Output lebt in text.format, nicht in response_format von Chat Completions.

Agents API ist das verwaltete Harness: POST /v1/agents/sessions. Sie deklarieren Agent, Tools, Environment; OpenAI dreht Schleife, Compact und Recovery. Wenn Ihre Funktion antworten muss, sendet die Session requires_action; Sie geben ein tool_result mit turn_id / call_id zurück.

Agents SDK ist kein drittes Protokoll. Es ist ein Runner in Ihrem Prozess: Handoffs, Freigaben, Speicher bleiben bei Ihnen; Modellaufrufe landen oft auf Responses. Die Doku behandelt Session, SDK-Session, Responses-Conversation und Sandbox als vier Ressourcen.

Tool Calling: eine Kette, zwei Rückschreiben

Auf Responses machen Sie jedes Mal responses.create. Tool-Tabelle und Endkarte können in derselben Anfrage stehen:

{
  "model": "gpt-6-astra",
  "input": "Look up order A-1042.",
  "tools": [
    {
      "type": "function",
      "name": "lookup_order",
      "parameters": {
        "type": "object",
        "properties": {
          "order_id": { "type": "string", "pattern": "^[A-Z]-\\d{4}$" }
        },
        "required": ["order_id"],
        "additionalProperties": false
      }
    }
  ],
  "text": {
    "format": {
      "type": "json_schema",
      "name": "order_card",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "order_id": { "type": "string" },
          "status": { "enum": ["paid", "pending", "void"] }
        },
        "required": ["order_id", "status"],
        "additionalProperties": false
      }
    }
  }
}

Braucht das Modell eine Abfrage, hält output ein eigenes Item. call_id nagelt Aufruf und Ergebnis fest:

{
  "output": [
    {
      "type": "function_call",
      "call_id": "call_3c91",
      "name": "lookup_order",
      "arguments": "{\"order_id\":\"A-1042\"}"
    }
  ]
}

Ihre App führt die Funktion aus und schickt das Ergebnis als nächstes Input-Item zurück:

{
  "type": "function_call_output",
  "call_id": "call_3c91",
  "output": "{\"status\":\"paid\",\"amount\":99.00}"
}

Agents API faltet diese Runden in eine Session. Einmal anlegen: Tools, Sandbox, ob multi_agent an ist:

{
  "agent": {
    "model": "gpt-6-astra",
    "tools": [
      { "type": "function", "name": "lookup_order", "parameters": {
        "type": "object",
        "properties": { "order_id": { "type": "string", "pattern": "^[A-Z]-\\d{4}$" } },
        "required": ["order_id"],
        "additionalProperties": false
      }},
      { "type": "web_search" }
    ],
    "multi_agent": { "enabled": true, "max_concurrent_subagents": 3 }
  },
  "environment": { "type": "hosted", "workspace_directory": "/workspace" },
  "input": [{ "role": "user", "content": [{ "type": "input_text", "text": "Look up A-1042." }] }]
}

Ist Ihre Funktion fällig, hält das Harness auf required_actions. Das Rückschreiben ist kein function_call_output, sondern ein Tool-Result mit turn_id:

{
  "type": "tool_result",
  "turn_id": "turn_2",
  "call_id": "call_3c91",
  "success": true,
  "output": "{\"status\":\"paid\"}"
}

Die Namen differieren. Das Tor nicht: Schema entscheidet, was ausführen darf. Die MCP-Zeile ist eine andere Schreibweise derselben Tabelle; Grenze in MCP Tool Schema vs. Function Calling.

Structured Output sperrt die Endkarte, nicht die Tool-Argumente

Responses legt die Endform in text.format. Das begrenzt, was der Nutzer sieht, nicht die Tool-Argumente. Tools brauchen ihr eigenes Schema. Vertrag in Warum KI JSON Schema braucht.

• Responses: text.format.json_schema + strict: true sperrt die Endkarte.
• Agents API: die Schleife ist gehostet; das Endartefakt will trotzdem ein Schema. Function-/MCP-Parameter bleiben eng.
• Beide: Structured Output ist kein Tor. Beträge, Bestätigung und Freigabe schreibt der Host.

Der übliche Fehler: nur die Karte sperren und lookup_order als weites object lassen. Die Karte sieht sauber aus. Die Nebenwirkung lief schon.

Multi-Agent: gehostetes Auffächern oder eigener Handoff

„Multi-Agent-Zusammenarbeit“ ist keine dritte Intelligenz. Es ist, wer die Orchestrierung hält:

• Agents API: multi_agent.enabled. Jeder Subagent behält eigenen Kontext. Der Hauptagent nutzt create / wait / interrupt. Concurrency deckeln.
• Agents SDK: Handoff-Objekte leben in Ihrem Runner. Freigaben und Speicher bleiben bei Ihnen.
• Responses: kein eingebauter Subagent. Sie ketten responses.create selbst oder parken State in Conversations.

Ein Handoff sollte prüfbares JSON sein, nicht „bitte an die Buchhaltung“. Als Schema halten: JSON Schema und Agent-Workflows.

Eine Tabelle, drei Türen

Der offizielle Vergleich fällt auf Ingenieursfragen zusammen:

Es gibt keine „bessere API“. Es gibt nur „sitzt das Subjekt auf Ihrer Seite“.

Vier Fragen, die die Tür wählen

Nicht von der Produktseite wählen. Diese vier:

1. Darf die Geschäftsnnebenwirkung Ihren Prozess verlassen? Erstattungen und Schreibvorgänge, die Ihr Nicken brauchen, starten auf Responses oder dem SDK.
2. Überlebt der Job ein Kontextfenster? Ja, und Sie wollen nicht selbst compacten: Agents API.
3. Brauchen Sie eine Sandbox für Befehle und Dateien? Agents-API-Environment ist fertig. Responses lässt die Ausführungswelt bei Ihnen.
4. Brauchen Sie parallele Subagents? Ja, und Sie bauen keine Orchestrierung: multi_agent an, Concurrency-Deckel einfrieren.

Liegen alle vier „Ja“ auf der gehosteten Seite, Agents API. Muss ein Sprung in Ihrer Hand bleiben, Responses. Das SDK ist die Dritte: die Schleife ist Ihre, mit weniger Kleber.

Bevor Sie vergleichen, beide JSON-Spuren ausbreiten

Die falsche Tür heißt meist: niemand hat die Objekte angesehen. Legen Sie beide Spuren auf den Tisch.

• formatieren das Responses-output[] und die Agents-Session-Items. call_id muss passen.
• Mit JSONPath extrahieren name, arguments und text.format ziehen. Doku nicht mit dem Auge scannen.
• JSON Diff dieselbe Bestellung unter beiden Türen. Driftete die Schleife, zuerst die Rückschreibform, dann das Modell.
• Endkarten-Schema und Tool-Argument-Schema getrennt prüfen. Nur die Karte sperren ist Fassade.
• Keine Bestellungen oder Intranet-MCP-URLs in einen öffentlichen Formatter. JSONSort läuft lokal im Browser.

Lassen sich beide Spuren neu bauen, wählen Sie eine Tür — kein Slogan.

Fallstricke

• Glauben, Agents API ersetze Responses. Die Doku listet zwei Startpunkte. Astra-Tool-Calling geht weiter über Responses.
• Session und Conversation als eine Ressource behandeln. Eine zu löschen räumt die andere nicht.
• Schema nur auf der Endkarte, weite Tool-Argumente. Nebenwirkungen passieren, wenn der function_call läuft.
• multi_agent ohne Concurrency-Deckel. Gehostetes Auffächern verbrennt weiter Tokens und weitet Nebenwirkungen.
• SDK nutzen und das Tor weglassen. Der Runner dreht die Schleife. Er prüft den Betrag nicht.
• Eine API aus einem Demovideo wählen. Das Demo hat die Schleife versteckt. Fragen Sie, wo das Subjekt sitzt.

FAQ

Mit welcher API sollte ein 2026er Projekt starten?

Mit Responses: Sie sehen jeden Sprung. Die Schleife nur an Agents API geben, wenn der Job Fenster überspannen muss oder Sie eine gehostete Sandbox oder Subagents brauchen.

Kann GPT-6 Astra nur Agents API nutzen und Responses überspringen?

Sie können nur eine Agents-Session öffnen. Astras Tool-Calling-Doku zeigt weiter auf Responses. Kurze Ketten, Structured Output und eine Schleife, die Sie selbst drehen, bleiben auf Responses.

Kann Structured Output Tool Calling ersetzen?

Nein. Structured Output sperrt das Endobjekt. Tool Calling sperrt Nebenwirkungen. Erstattungen, Lookups, Dateiänderungen gehen durch Tool-JSON; die Karte für den Nutzer durch text.format.

Braucht Multi-Agent die Agents API?

Nein. SDK-Handoffs und Ihre eigene Kette von Responses-Aufrufen sind auch Multi-Agent. Agents API macht Auffächern nur zur gehosteten Fähigkeit.

Kann ich beide APIs mischen?

Ja — die Ressourcen nicht. Strukturierte Karte auf Responses; langer Job auf einer Agents-Session. Session, Conversation und Sandbox getrennt anlegen und löschen.

Fazit

Agents API und Responses API sind keine zwei Generationen. Eine hostet die Schleife. Die andere gibt sie Ihnen. Tool Calling, Structured Output und Multi-Agent sind nur verschiedene Objekte auf dieser Kette.

Zuerst das Subjekt schreiben: darf dieser Sprung Ihren Prozess verlassen? Dann die Tür wählen. Modelle wechseln. call_id und Schema sollten zuerst stehen.

Weiterlesen

• OpenAI Agents API, kompletter Rundgang Wie Session, Tool Calling und Schema zusammenhängen
• Was ist ein AI Agent? Kompletter Leitfaden Runtime und der JSON-Vertrag
• Warum KI JSON Schema braucht Schema / Function Calling / Structured Output
• JSON Schema und Agent-Workflows Tools und State als Schema halten
• MCP Tool Schema vs. Function Calling Protokollgrenze für Tool-JSON
• JSONSort lokaler Werkzeugkasten Formatieren, prüfen, Diff
• Alle Beiträge Weitere JSON- und KI-Notizen

Änderungsprotokoll: 2026-09-21 Erstveröffentlichung