OpenAI Agents SDK: GPT-6.1 Sol Agent in 12 Schritten

Seit Ende September 2026 liegt zwischen einem einfachen Chatbot und einem echten Software-Agenten nur noch eine Handvoll Zeilen Python-Code. Mit GPT-6.1 Sol hat OpenAI am 29. September ein Modell veröffentlicht, das nach eigenen Angaben nahe an die Fähigkeiten des Flaggschiffs GPT-6 Astra heranreicht, bei Agentencoding, Computer-Nutzung und Büroaufgaben, und das zu einem Fünftel des Standardpreises von Astra. Zusammen mit dem OpenAI Agents SDK ergibt sich daraus eine Kombination, mit der sich eigenständig arbeitende Agenten günstig bauen und betreiben lassen. Für deutsche Entwicklerteams, die bisher aus Kostengründen bei einfachen Chat-Integrationen geblieben sind, verschiebt sich damit die Kalkulation: Ein Agent, der mehrere Zwischenschritte braucht, muss nicht mehr automatisch das teuerste verfügbare Modell nutzen, um brauchbare Ergebnisse zu liefern.

Dieses Tutorial zeigt in 12 Schritten, wie ein lauffähiger Agent mit dem OpenAI Agents SDK und GPT-6.1 Sol entsteht: vom leeren Projektordner bis zu einem gestreamten FastAPI-Endpunkt mit Tools, Handoffs, Guardrails und Tracing. Am Ende steht ein komplettes Projekt, das sich direkt weiterverwenden lässt, inklusive Preisvergleich, Troubleshooting und einer Einordnung gegenüber CrewAI, LangGraph und Claudes Computer-Use-Tool.

Was ist das OpenAI Agents SDK? GPT-6.1 Sol, Astra und Luna im Überblick

Das OpenAI Agents SDK ist ein schlankes Python- und TypeScript-Framework, mit dem sich Agenten, Werkzeuge und deren Zusammenspiel in Code abbilden lassen, ohne auf ein schweres Orchestrierungs-Framework zurückzugreifen. OpenAI beschreibt das Ziel in der offiziellen Dokumentation so: “The OpenAI Agents SDK enables you to build agentic AI apps in a lightweight, easy-to-use package with very few abstractions.” Im April 2026 erhielt das SDK ein größeres Update: einen modell-nativen Harness, mit dem Agenten Dateien lesen, Befehle ausführen und Code bearbeiten können, plus eine native Sandbox-Ausführung für sicheres Arbeiten über längere Aufgaben hinweg. Diese Fähigkeiten laufen zunächst nur in Python, eine TypeScript-Version war zum Zeitpunkt der Ankündigung noch nicht terminiert.

Beim DevDay 2026 verband OpenAI die neue Modellreihe zusätzlich mit einer eigenen Geschwindigkeitsstufe namens Ultrafast. Laut den Ankündigungen aus der offiziellen Community-Übersicht erreicht diese Stufe eine bis zu 8-fach schnellere Token-Generierung in Codex und eine 6-fach schnellere Generierung über die reguläre API. Für Agenten, die mehrere Schritte in Serie ausführen, etwa erst planen, dann ein Tool aufrufen und erst danach antworten, wirkt sich eine solche Beschleunigung direkt auf die gefühlte Reaktionszeit aus, unabhängig vom gewählten Preismodell.

Parallel dazu hat sich die Modellreihe von OpenAI im Spätsommer 2026 deutlich verzweigt. GPT-6 Astra kam als Computer-Use-Flaggschiff mit einem Kontextfenster von 1,05 Millionen Tokens und erreichte im OSWorld-V2-Offline-Benchmark 72,6 Prozent, einem Test für zuverlässiges Handeln in echten grafischen Arbeitsumgebungen. Am 22. September folgten die günstigeren Varianten GPT-6 Sol und GPT-6 Luna, und nur eine Woche später, am 29. September, brachte OpenAI mit GPT-6.1 Sol ein Upgrade, das nach Unternehmensangaben nahezu die Qualität von Astra erreicht, aber nur ein Fünftel des Input- und Output-Preises kostet. Für ein Tutorial ist genau das der interessante Punkt: Wer heute einen Agenten baut, muss nicht mehr automatisch zum teuersten Modell greifen.

Der September 2026 war laut den Statistiken von BenchLM ohnehin der aktivste Monat für KI-Modellveröffentlichungen der letzten zwölf Monate, mit 42 erfassten Releases. BenchLM listet mittlerweile 783 Modelle, davon 74 mit vollständig unterstützten und 138 mit geschätzten Benchmark- und Preisdaten. Wer ein Agentenprojekt plant, sollte Preise und Fähigkeiten also nicht einmalig nachschlagen, sondern laufend prüfen, denn die Landschaft verschiebt sich inzwischen wochenweise.

Voraussetzungen: Python-Version, API-Key und Pakete

Bevor es an den Code geht, braucht es eine saubere Grundlage. Die folgende Tabelle fasst zusammen, was für dieses Tutorial installiert sein sollte.

Komponente	Empfehlung	Hinweis
Python	3.11 oder 3.12	Agents SDK setzt moderne Typisierung (TypedDict, Generics) voraus
Paket-Manager	pip oder uv	uv beschleunigt die Installation der Abhängigkeiten deutlich
OpenAI-Paket	openai-agents (aktuelle Version)	Installation per pip install openai-agents
API-Zugang	OpenAI-API-Key mit Guthaben	Zugriff auf gpt-6.1-sol, gpt-6-astra, gpt-6-luna erforderlich
Webserver	FastAPI + Uvicorn	Für den Streaming-Endpunkt in Schritt 12
Optional	Pydantic 2.x	Für strukturierte Agentenausgaben in Schritt 5

Ein API-Key allein reicht nicht, wenn das Konto keinen Zugriff auf die GPT-6-Modellfamilie hat. Wer bisher nur mit älteren Modellen gearbeitet hat, etwa im Rahmen unseres Tutorials zum OpenAI-API-Setup mit GPT-5.6 Sol, sollte vor dem Start im OpenAI-Dashboard prüfen, ob gpt-6.1-sol und gpt-6-astra in der Modellliste des eigenen Projekts auftauchen. Fehlt das, hilft meist nur ein Upgrade der Organisation oder etwas Geduld, da OpenAI neue Modelle oft stufenweise freischaltet.

Ein zweiter, häufig übersehener Punkt sind Rate Limits. Neue Modelle starten bei OpenAI in der Regel mit niedrigeren Anfragelimits pro Minute als etablierte Modelle, die bereits länger im Einsatz sind. Wer direkt zum Start eines Agentenprojekts mit hoher Last testet, etwa durch parallele Lasttests mit mehreren hundert gleichzeitigen Anfragen, läuft Gefahr, frühzeitig gegen diese Grenzen zu stoßen. Für dieses Tutorial reicht ein reguläres Entwicklerkonto völlig aus, für den produktiven Betrieb mit echtem Nutzeraufkommen lohnt sich aber ein Blick in die aktuellen Limits im OpenAI-Dashboard, bevor ein Launch-Termin feststeht.

Grundkonzepte: Agent, Runner, Tools, Handoffs und Guardrails

Das Agents SDK arbeitet mit wenigen, klar abgegrenzten Bausteinen. Ein Agent bündelt Instruktionen, ein Modell und eine Liste von Werkzeugen. Der Runner führt einen Agenten aus und kümmert sich um die Schleife aus Modellantworten und Tool-Aufrufen. Tools sind normale Python-Funktionen, die per Dekorator für den Agenten sichtbar werden. Handoffs erlauben es einem Agenten, eine Aufgabe gezielt an einen anderen, spezialisierten Agenten weiterzugeben. Guardrails prüfen Ein- und Ausgaben, bevor sie das System verlassen oder weiterverarbeitet werden. Wer dieses Vokabular einmal verinnerlicht hat, liest sich durch den Rest des Tutorials deutlich leichter.

Ein weiterer Baustein, der in einfachen Beispielen oft fehlt, ist der Kontext, den das SDK als ctx-Objekt durch die gesamte Ausführung reicht. Darüber lassen sich Informationen wie eine Nutzer-ID, Mandanten-Kennung oder Berechtigungsstufe an Tools und Guardrails weitergeben, ohne sie in jeder einzelnen Funktion erneut übergeben zu müssen. Gerade in Mehrbenutzer-Systemen, bei denen ein Agent für verschiedene Kunden oder Abteilungen gleichzeitig läuft, spart das spürbar Code und reduziert das Risiko, eine Berechtigungsprüfung an einer Stelle schlicht zu vergessen.

Schritt 1 bis 3: Projekt anlegen und Agents SDK installieren

Der erste Block aus drei Schritten schafft die Arbeitsumgebung: Projektordner anlegen, virtuelle Umgebung aktivieren und die nötigen Pakete installieren.

# Schritt 1: Projektordner anlegen
mkdir gpt6-agent-tutorial && cd gpt6-agent-tutorial

# Schritt 2: Virtuelle Umgebung erstellen und aktivieren
python3 -m venv .venv
source .venv/bin/activate   # unter Windows: .venv\Scripts\activate

# Schritt 3: Pakete installieren
pip install openai-agents fastapi uvicorn pydantic python-dotenv

Direkt danach sollte der API-Key als Umgebungsvariable gesetzt werden, am saubersten über eine .env-Datei im Projektordner:

# .env
OPENAI_API_KEY=sk-dein-schluessel-hier

Wer stattdessen lieber direkt mit der REST-API ohne SDK experimentiert, findet den passenden Einstieg in unserem Artikel zum OpenAI-API-Setup. Für alles, was über einfache Textanfragen hinausgeht, lohnt sich aber der Umstieg auf das Agents SDK, weil es Tool-Aufrufe, Zustandsverwaltung und Streaming bereits mitbringt.

Schritt 4 und 5: Ersten Agenten erstellen und Function Tools anbinden

Ein Agent besteht im Minimalfall aus einem Namen, einer Instruktion und einem Modell. Schritt 4 zeigt das Grundgerüst, Schritt 5 ergänzt ein eigenes Werkzeug, das der Agent bei Bedarf selbst aufruft.

from agents import Agent, Runner, function_tool

# Schritt 4: Agent mit GPT-6.1 Sol definieren
support_agent = Agent(
    name="Support-Agent",
    instructions=(
        "Du beantwortest technische Supportfragen auf Deutsch, "
        "kurz und konkret. Nutze Tools, wenn du Daten nachschlagen musst."
    ),
    model="gpt-6.1-sol",
)

# Schritt 5: Eigenes Function Tool anbinden
@function_tool
def ticket_status(ticket_id: str) -> str:
    """Gibt den aktuellen Status eines Support-Tickets zurück."""
    status_datenbank = {"T-1001": "in Bearbeitung", "T-1002": "gelöst"}
    return status_datenbank.get(ticket_id, "unbekanntes Ticket")

support_agent.tools = [ticket_status]

result = Runner.run_sync(support_agent, "Wie ist der Status von Ticket T-1001?")
print(result.final_output)

Ein typischer Lauf liefert eine Ausgabe wie die folgende, der Agent ruft dabei intern das Tool auf, bevor er antwortet:

Ticket T-1001 befindet sich aktuell in Bearbeitung.
Du erhältst eine Benachrichtigung, sobald sich der Status ändert.

Schritt 6 und 7: Strukturierte Ausgaben und Handoffs zwischen Agenten

Für produktive Systeme reicht ein freier Textblock selten aus. Mit output_type lässt sich festlegen, dass der Agent ein Pydantic-Modell zurückgibt, das sich direkt weiterverarbeiten lässt. Schritt 7 zeigt zusätzlich einen Handoff: Der Support-Agent erkennt Abrechnungsfragen und übergibt sie an einen spezialisierten Billing-Agenten.

from pydantic import BaseModel
from agents import Agent, Runner

# Schritt 6: Strukturierte Ausgabe
class TicketAntwort(BaseModel):
    ticket_id: str
    zusammenfassung: str
    eskalieren: bool

analyse_agent = Agent(
    name="Analyse-Agent",
    instructions="Fasse Supportanfragen strukturiert zusammen.",
    model="gpt-6.1-sol",
    output_type=TicketAntwort,
)

# Schritt 7: Handoff an einen Billing-Agenten
billing_agent = Agent(
    name="Billing-Agent",
    instructions="Du beantwortest ausschließlich Abrechnungsfragen.",
    model="gpt-6.1-sol",
)

support_agent = Agent(
    name="Support-Agent",
    instructions="Leite Abrechnungsfragen an den Billing-Agenten weiter.",
    model="gpt-6.1-sol",
    handoffs=[billing_agent],
)

result = Runner.run_sync(support_agent, "Warum wurde meine Kreditkarte doppelt belastet?")
print(result.final_output)

Handoffs lösen ein Problem, das bei einem einzigen, überladenen Agenten häufig auftritt: eine Instruktion, die zehn verschiedene Themen gleichzeitig abdecken soll, liefert in der Praxis für jedes dieser Themen schlechtere Ergebnisse als ein schmaler, fokussierter Agent.

Schritt 8: Guardrails für Input und Output einrichten

Guardrails prüfen Eingaben, bevor sie den Agenten erreichen, und Ausgaben, bevor sie den Nutzer erreichen. Das folgende Beispiel blockiert Anfragen, die nach Kreditkartendaten im Klartext fragen, und verhindert damit, dass ein Agent versehentlich sensible Daten verarbeitet oder zurückgibt.

from agents import input_guardrail, GuardrailFunctionOutput

@input_guardrail
def keine_kreditkartendaten(ctx, agent, input_text: str) -> GuardrailFunctionOutput:
    verdachtsmuster = ["kreditkartennummer", "cvv", "pin eingeben"]
    treffer = any(muster in input_text.lower() for muster in verdachtsmuster)
    return GuardrailFunctionOutput(
        output_info="Sensible Zahlungsdaten erkannt" if treffer else "unauffällig",
        tripwire_triggered=treffer,
    )

support_agent.input_guardrails = [keine_kreditkartendaten]

Wird die Tripwire ausgelöst, bricht der Runner die Ausführung ab, statt die Anfrage an das Modell weiterzuleiten. Für Agenten, die mit echten Kundendaten arbeiten, ist das kein optionales Feature, sondern der Unterschied zwischen einem vertretbaren und einem riskanten Deployment.

Schritt 9 und 10: Sessions und Streaming in Echtzeit

Ohne Sessions vergisst ein Agent nach jeder Antwort den Gesprächsverlauf. Schritt 9 fügt eine Session hinzu, Schritt 10 schaltet Streaming ein, sodass die Antwort Wort für Wort beim Nutzer ankommt statt erst am Ende komplett.

from agents import Agent, Runner, SQLiteSession

# Schritt 9: Persistente Session anlegen
session = SQLiteSession("nutzer_4711", "gespraeche.db")

result = Runner.run_sync(support_agent, "Mein Drucker verbindet sich nicht.", session=session)
print(result.final_output)

# Schritt 10: Streaming der Antwort
import asyncio

async def stream_antwort():
    stream = Runner.run_streamed(support_agent, "Und wie sieht es mit WLAN-Druckern aus?", session=session)
    async for event in stream.stream_events():
        if event.type == "raw_response_event":
            print(event.data, end="", flush=True)

asyncio.run(stream_antwort())

Die Session speichert den Verlauf in einer lokalen SQLite-Datei, für Produktionssysteme lässt sich die gleiche Schnittstelle an eine Redis- oder Postgres-Anbindung koppeln. Wichtig ist nur, dass dieselbe Session-ID über mehrere Anfragen hinweg verwendet wird, sonst beginnt der Agent faktisch jedes Mal neu.

Schritt 11: MCP-Server und Tracing einbinden

Statt jedes Tool händisch in Python zu schreiben, lässt sich ein Agent auch an einen bestehenden MCP-Server anbinden, etwa für Dateisystemzugriff, Datenbankabfragen oder Drittanbieter-APIs. Wer MCP noch nicht kennt, findet eine ausführliche Einführung in unserem Tutorial zum MCP-Server-Setup. Im Agents SDK reicht dafür wenige Zeilen Code:

from agents import Agent
from agents.mcp import MCPServerStdio

dateisystem_server = MCPServerStdio(
    name="Dateisystem",
    params={"command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "./daten"]},
)

agent_mit_mcp = Agent(
    name="Dateisystem-Agent",
    instructions="Beantworte Fragen zu Dateien im Ordner ./daten.",
    model="gpt-6.1-sol",
    mcp_servers=[dateisystem_server],
)

Für die Fehlersuche lohnt sich außerdem das eingebaute Tracing. Jeder Lauf lässt sich als Trace mit allen Modellaufrufen, Tool-Aufrufen und Handoffs einsehen, was bei mehrstufigen Agenten den Unterschied zwischen einer vagen Vermutung und einer konkreten Fehlerursache ausmacht. Gerade bei Handoff-Ketten mit drei oder vier beteiligten Agenten ist das Trace-Protokoll oft die einzige Möglichkeit, nachzuvollziehen, an welcher Stelle eine Antwort falsch abgebogen ist.

Schritt 12: Alles zusammenführen – FastAPI-Endpunkt mit GPT-6.1 Sol

Im letzten Schritt wird aus den einzelnen Bausteinen ein komplettes, lauffähiges Projekt: ein FastAPI-Server, der Anfragen entgegennimmt, den Support-Agenten mit Tool, Guardrail und Session ausführt und die Antwort als Stream zurückgibt.

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from agents import Agent, Runner, SQLiteSession, function_tool

app = FastAPI()
session_store = {}

@function_tool
def ticket_status(ticket_id: str) -> str:
    """Gibt den aktuellen Status eines Support-Tickets zurück."""
    return {"T-1001": "in Bearbeitung", "T-1002": "gelöst"}.get(ticket_id, "unbekannt")

support_agent = Agent(
    name="Support-Agent",
    instructions="Beantworte Supportfragen auf Deutsch, kurz und konkret.",
    model="gpt-6.1-sol",
    tools=[ticket_status],
)

@app.get("/chat")
async def chat(nutzer_id: str, frage: str):
    session = session_store.setdefault(nutzer_id, SQLiteSession(nutzer_id, "gespraeche.db"))

    async def event_stream():
        stream = Runner.run_streamed(support_agent, frage, session=session)
        async for event in stream.stream_events():
            if event.type == "raw_response_event":
                yield str(event.data)

    return StreamingResponse(event_stream(), media_type="text/plain")

# Start: uvicorn main:app --reload

Mit uvicorn main:app –reload gestartet, lässt sich der Endpunkt sofort über /chat?nutzer_id=max&frage=Wie ist der Status von T-1002 testen. Für den produktiven Einsatz fehlen an dieser Stelle noch Authentifizierung, Rate-Limiting und ein externer Session-Speicher, aber die Grundarchitektur, Agent, Tool, Session, Streaming, FastAPI, steht.

Output-Beispiel: Ein kompletter Trace-Lauf im Detail

Wie ein Trace aus Schritt 11 konkret aussieht, zeigt sich am besten an einem Beispiel mit Handoff. Ein Nutzer fragt nach einer doppelten Kreditkartenbelastung, der Support-Agent erkennt das Thema und übergibt an den Billing-Agenten. Das vereinfachte Protokoll eines solchen Laufs sieht in etwa so aus:

Trace-ID: trace_8f2a91
Schritt 1: Agent "Support-Agent" (gpt-6.1-sol) empfängt Eingabe
Schritt 2: Modell erkennt Abrechnungsthema, löst Handoff aus
Schritt 3: Handoff an Agent "Billing-Agent" (gpt-6.1-sol)
Schritt 4: Billing-Agent generiert Antwort ohne weiteren Tool-Aufruf
Gesamtdauer: 2,1 Sekunden
Token-Nutzung: 412 Input, 96 Output, 0 gecacht

Entscheidend an diesem Protokoll ist weniger die Dauer als die Token-Aufteilung. In diesem Beispiel entstehen durch den Handoff zwei getrennte Modellaufrufe, einen beim Support-Agenten bis zur Erkennung des Themas und einen beim Billing-Agenten für die eigentliche Antwort. Wer Kosten nur anhand der sichtbaren Endantwort schätzt, übersieht genau diesen ersten, kürzeren Aufruf. Bei einem Agenten mit zusätzlichem Tool-Aufruf käme ein dritter Eintrag hinzu, nämlich der Moment, in dem das Modell die Funktion aufruft und auf das Ergebnis wartet, bevor es die finale Antwort formuliert.

Deployment: Den Agenten produktiv betreiben

Der FastAPI-Endpunkt aus Schritt 12 funktioniert lokal, für einen produktiven Betrieb braucht es aber noch einige Ergänzungen. Am Anfang steht meist ein einfaches Dockerfile, das die Anwendung reproduzierbar verpackt und sich direkt in bestehende Deployment-Pipelines einfügt:

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Darüber hinaus sollten produktive Deployments drei Dinge zusätzlich mitbringen. Erstens eine getrennte Konfiguration für Entwicklung, Staging und Produktion, inklusive eigener API-Keys pro Umgebung, damit ein Fehler in der Staging-Umgebung nie das Produktionsbudget betrifft. Zweitens einen externen Session-Speicher wie Redis oder Postgres statt der lokalen SQLite-Datei aus Schritt 9, weil SQLite bei mehreren parallel laufenden Containern schnell zum Flaschenhals wird. Drittens eine strukturierte Protokollierung, die neben der eigentlichen Antwort auch Trace-ID, verwendetes Modell und Token-Verbrauch je Anfrage festhält, damit sich Kostenspitzen später einer einzelnen Anfrage oder einem einzelnen Kunden zuordnen lassen. Ohne diese drei Punkte läuft ein Agent zwar auch produktiv, aber ohne verlässliche Antwort auf die Frage, was im Fehlerfall tatsächlich passiert ist.

Ein einfacher Health-Check-Endpunkt, der unabhängig vom eigentlichen Agenten prüft, ob die OpenAI-API aktuell erreichbar ist und ob der Session-Speicher antwortet, gehört ebenfalls zur Grundausstattung. Schlägt die API-Verbindung fehl, etwa durch eine kurzfristige Störung oder ein abgelaufenes Guthaben, sollte der Endpunkt eine klare Fehlermeldung statt eines unklaren Timeouts liefern, damit vorgeschaltete Systeme oder Load Balancer den betroffenen Container zuverlässig aus der Rotation nehmen können.

Modellwahl: GPT-6.1 Sol, GPT-6 Astra und GPT-6 Luna im Preisvergleich

Die Wahl des Modells entscheidet bei Agenten stärker über die Kosten als bei einfachen Chat-Anwendungen, weil ein Agent pro Anfrage oft mehrere Modellaufrufe auslöst, etwa für Planung, Tool-Aufruf und finale Antwort. Die folgende Tabelle zeigt die bekannten Preise der drei aktuellen GPT-6-Varianten.

Modell	Input pro 1 Mio. Token	Output pro 1 Mio. Token	Besonderheit
GPT-6 Luna	0,10 $	0,50 $	Günstigste GPT-6-Variante, veröffentlicht am 22.09.2026
GPT-6.1 Sol	2 $	10 $	Gecachter Input nur 0,10 $, Astra-nahe Qualität, veröffentlicht am 29.09.2026
GPT-6 Astra	10 $	50 $	Computer-Use-Flaggschiff, 1,05 Mio. Token Kontext, 72,6 % auf OSWorld V2-Offline

Rechnerisch liegt GPT-6.1 Sol bei Input und Output exakt bei einem Fünftel des Astra-Preises, also 80 Prozent günstiger, und erreicht laut OpenAI dennoch nahezu dieselbe Qualität bei Agentencoding, Computer-Nutzung und professionellen Aufgaben. Für die meisten Agentenprojekte aus diesem Tutorial ist Sol deshalb der sinnvollere Standard. Astra lohnt sich vor allem dann, wenn ein Agent eigenständig grafische Oberflächen bedienen soll und die letzten Prozentpunkte an Zuverlässigkeit messbar etwas wert sind, etwa bei Browser-Automatisierung mit vielen Zwischenschritten. Luna eignet sich für einfache Klassifikations- oder Zusammenfassungsaufgaben, bei denen die Antwortqualität von GPT-6.1 Sol schlicht nicht gebraucht wird.

Ein Beispiel verdeutlicht den Unterschied in echten Zahlen. Bei 10.000 Supportanfragen pro Monat mit durchschnittlich 500 Input- und 150 Output-Token je Anfrage kostet ein Agent auf Basis von GPT-6.1 Sol überschlägig 10 Dollar für den Input und 15 Dollar für den Output, zusammen also rund 25 Dollar monatlich allein für die Modellaufrufe. Derselbe Agent auf Basis von GPT-6 Astra würde bei identischem Token-Verbrauch auf etwa 125 Dollar kommen, ein Faktor von fünf. Bei höherem Volumen oder zusätzlichen Zwischenschritten durch Tool-Aufrufe und Handoffs skaliert dieser Unterschied entsprechend mit, weshalb sich die Modellwahl bei Agenten lohnt, bevor der erste produktive Rollout startet, und nicht erst, wenn die erste Rechnung überrascht.

OpenAI Agents SDK im Vergleich: CrewAI, LangGraph und Claude Computer Use

Das Agents SDK ist nicht die einzige Möglichkeit, Agenten zu bauen. Wer bereits mit CrewAI gearbeitet hat, kennt das rollenbasierte Modell mit Crews, Tasks und Prozessen, das stärker auf vordefinierte Teamstrukturen setzt. LangGraph bildet Agenten dagegen als expliziten Graphen aus Knoten und Kanten ab, was bei sehr verzweigten Entscheidungspfaden Vorteile bringt, aber auch mehr Code erfordert. Das OpenAI Agents SDK positioniert sich bewusst dazwischen: weniger Abstraktion als LangGraph, aber modellnäher als CrewAI, weil es direkt auf die Responses-API von OpenAI zugeschnitten ist.

Beim Thema Computer-Nutzung lohnt sich der Blick zu Anthropic. Claudes Computer-Use-Werkzeug läuft über ein eigenes Toolset mit der Kennung computer_toolset_20260801 und stellt Claude 17 Einzeloperationen wie Screenshot, Linksklick, Texteingabe oder Zoom zur Verfügung, wie es in der Claude-Plattform-Dokumentation beschrieben wird. Die Architektur ist dabei bewusst anwendungsvermittelt: Claude fordert eine Aktion an, die eigene Anwendung führt sie in einer kontrollierten Umgebung aus und schickt das Ergebnis zurück. Das Toolset ist über die Claude-API und Google Cloud verfügbar, aber noch nicht in Claudes Managed Agents integriert. OpenAIs Ansatz mit GPT-6 Astra verfolgt eine ähnliche Grundidee, nutzt aber ein eigenes Tool-Schema, weshalb sich Code zwischen beiden Anbietern nicht eins zu eins übertragen lässt.

Für Teams, die sich noch nicht festlegen wollen, lohnt sich ein pragmatischer Blick auf die vorhandene Infrastruktur. Wer bereits Python-Services mit OpenAI-Modellen betreibt, kommt mit dem Agents SDK am schnellsten ans Ziel, weil keine zusätzliche Abstraktionsschicht nötig ist. Wer dagegen mehrere Modellanbieter gleichzeitig einsetzt, etwa aus Gründen der Ausfallsicherheit oder weil unterschiedliche Abteilungen unterschiedliche Anbieter bevorzugen, fährt mit CrewAI oder LangGraph oft besser, da beide Frameworks von Beginn an auf Provider-Unabhängigkeit ausgelegt sind. Entscheidend ist am Ende weniger die Frage, welches Framework auf dem Papier mehr Funktionen bietet, sondern wie gut es zur bestehenden Codebasis und zum vorhandenen Know-how im Team passt.

Framework	Grundprinzip	Besonders geeignet für
OpenAI Agents SDK	Code-first, wenige Abstraktionen, Sandbox und Harness integriert	Schnelle Agenten direkt auf GPT-6-Modellen
CrewAI	Rollenbasierte Crews mit Tasks und Prozessen	Teams aus mehreren spezialisierten Agenten mit festen Rollen
LangGraph	Expliziter Graph aus Knoten und Zuständen	Komplexe, stark verzweigte Entscheidungslogik
Claude Computer Use	Anwendungsvermitteltes Toolset mit 17 Operationen	GUI-Steuerung mit striktem Entwickler-Sandboxing

5 häufige Fehler beim Einstieg ins Agents SDK

Die meisten Probleme, die neue Teams mit dem Agents SDK haben, lassen sich nicht auf Bugs im Framework zurückführen, sondern auf fünf wiederkehrende Denkfehler beim Aufbau der Agentenlogik. Wer diese von Anfang an vermeidet, erspart sich mehrere Debugging-Runden.

Kein Guardrail bei nutzergenerierten Eingaben: Ohne Input-Guardrail verarbeitet der Agent jede Eingabe unverändert an das Modell, auch Versuche, die Systemanweisung per Prompt Injection zu überschreiben.
Zu viele Aufgaben in einem einzigen Agenten: Eine Instruktion, die Support, Abrechnung und technische Diagnose gleichzeitig abdecken soll, liefert für jedes Teilthema spürbar schwächere Ergebnisse als drei fokussierte Agenten mit Handoffs.
Sessions ohne feste ID: Wird für jede Anfrage eine neue Session-ID erzeugt, beginnt der Agent faktisch jedes Mal von vorn und wirkt vergesslich, obwohl die Session-Funktion technisch korrekt eingebunden ist.
Teures Modell für einfache Aufgaben: GPT-6 Astra für eine einfache Textklassifikation einzusetzen, kostet ein Vielfaches gegenüber GPT-6 Luna, ohne einen messbaren Qualitätsgewinn zu bringen.
Tool-Funktionen ohne Docstring: function_tool nutzt den Python-Docstring, um dem Modell zu erklären, wofür ein Werkzeug gedacht ist. Fehlt dieser, ruft das Modell das Tool seltener oder in falschen Situationen auf.

Troubleshooting: Lösungen für die häufigsten Probleme

Über die fünf grundsätzlichen Fehler hinaus tauchen beim praktischen Einsatz regelmäßig dieselben acht technischen Probleme auf. Die folgende Liste ordnet jedem davon die wahrscheinlichste Ursache und den schnellsten Lösungsweg zu.

Fehler “model not found” bei gpt-6.1-sol: Das Projekt hat noch keinen Zugriff auf die GPT-6-Familie. Im OpenAI-Dashboard unter Organisationseinstellungen prüfen oder etwas abwarten, da OpenAI neue Modelle oft gestaffelt freischaltet.
Agent ruft das Tool nie auf: Meist fehlt ein aussagekräftiger Docstring oder die Instruktion erwähnt das Werkzeug nicht. Eine explizite Formulierung wie “Nutze ticket_status, um den Status nachzuschlagen” löst das Problem fast immer.
Streaming bricht mitten im Satz ab: Häufig liegt das an einem zu knappen Timeout im Webserver. Bei FastAPI und Uvicorn hilft es, den Timeout für Keep-Alive-Verbindungen zu erhöhen.
Handoff landet beim falschen Agenten: Die Beschreibung des Ziel-Agenten in der Handoff-Liste ist zu allgemein formuliert. Je präziser die Instruktion des Quell-Agenten beschreibt, wann ein Handoff greifen soll, desto zuverlässiger die Weiterleitung.
Guardrail blockiert legitime Anfragen: Zu breite Verdachtsmuster erzeugen Fehlalarme. Muster erst an echten Beispielanfragen testen, bevor sie produktiv geschaltet werden.
SQLiteSession wächst unkontrolliert: Ohne Aufräumroutine sammelt sich der Gesprächsverlauf unbegrenzt an. Für Produktionssysteme empfiehlt sich ein Zeitlimit, nach dem alte Sessions archiviert oder gelöscht werden.
MCP-Server startet nicht: Häufigste Ursache ist ein fehlendes Node.js auf dem Server, da viele MCP-Server über npx gestartet werden. Node-Installation prüfen, bevor die Fehlersuche im Python-Code beginnt.
Kosten steigen schneller als erwartet: Ein Agent mit mehreren Tool-Aufrufen pro Anfrage zählt jeden Zwischenschritt als eigenen Modellaufruf. Mit dem Tracing aus Schritt 11 lässt sich genau sehen, wie viele Aufrufe ein einzelner Lauf tatsächlich auslöst.

Erweiterte Tipps für den Produktivbetrieb

Sobald ein Agent den Prototyp-Status verlässt, lohnen sich ein paar zusätzliche Maßnahmen. Erstens: gecachter Input gezielt nutzen. Bei GPT-6.1 Sol kostet gecachter Input nur 0,10 Dollar pro Million Token, ein Zehntel des normalen Preises, weshalb sich lange, wiederkehrende Systeminstruktionen oder Wissensbasis-Auszüge am Anfang des Prompts bündeln sollten, damit sie als Cache-Treffer erkannt werden. Zweitens: Tracing nicht nur zur Fehlersuche, sondern dauerhaft zur Kostenkontrolle einsetzen, denn Trace-Daten zeigen zuverlässiger als jede Schätzung, wie viele Modellaufrufe ein Agent pro Anfrage tatsächlich verursacht.

Drittens: bei Multi-Agenten-Systemen mit Handoffs auf klare Abbruchkriterien achten. Ein Agent, der eine Aufgabe zwischen zwei Spezialisten hin- und herreicht, ohne dass einer von beiden eine Lösung findet, sollte nach wenigen Runden an einen Menschen eskalieren, statt in einer Schleife zu verharren. Viertens: separate API-Keys oder Projekte für Entwicklung und Produktion verwenden, damit ein fehlerhafter Testlauf im Entwicklungssystem nicht versehentlich das Produktionsbudget belastet. Fünftens: bei Agenten, die auf MCP-Server zugreifen, die Rechte des Servers so eng wie möglich fassen, ein Dateisystem-Server etwa sollte nur auf den tatsächlich benötigten Ordner zugreifen können, nicht auf das gesamte Projektverzeichnis.

Sechstens: Prompt-Versionierung nicht unterschätzen. Instruktionen für Agenten verändern sich im Lauf eines Projekts ständig, oft durch kleine Anpassungen nach einem Fehlerfall. Wer diese Instruktionen zusammen mit dem restlichen Code in Versionskontrolle hält, statt sie in einer separaten Konfigurationsoberfläche zu pflegen, kann im Nachhinein nachvollziehen, welche Formulierung zu welchem Verhalten geführt hat, und notfalls gezielt auf eine frühere Version zurückrollen.

Sicherheit: Guardrails, Prompt Injection und Computer-Use-Risiken

Je mehr Handlungsspielraum ein Agent bekommt, desto wichtiger wird die Frage, was im Fehlerfall passieren kann. Bei reinen Text-Agenten ist das Risiko meist auf falsche oder unpassende Antworten begrenzt. Sobald ein Agent jedoch Tools mit echten Nebenwirkungen aufruft, etwa eine Datenbank verändert oder, wie bei GPT-6 Astra möglich, eine grafische Benutzeroberfläche bedient, verschiebt sich das Risiko auf reale Aktionen. Für solche Fälle gilt eine einfache Grundregel: destruktive oder finanzielle Aktionen, Löschungen, Käufe, Passwortänderungen, Logins, sollten grundsätzlich eine explizite Bestätigung durch einen Menschen erfordern, unabhängig davon, wie sicher sich das Modell selbst erscheint.

Guardrails und Tracing aus diesem Tutorial decken dabei nur einen Teil ab. Wer Agenten mit sensiblen Daten oder Zugriff auf Unternehmenssysteme betreibt, sollte zusätzlich eine Allowlist für Zieladressen, ein Protokoll aller Aktionen und einen harten Stopp bei Mehrdeutigkeit einplanen. Unternehmen, die zusätzlich verhindern wollen, dass Mitarbeitende versehentlich sensible Daten über Chat-Tools weitergeben, finden ergänzende Ansätze in unserem Artikel zu Claude-API-Setup und Modellvergleich, der auch auf Sicherheitsabwägungen zwischen Anbietern eingeht.

Ein weiterer Risikobereich betrifft die Interaktion zwischen mehreren Agenten über Handoffs. Je mehr Agenten an einer Kette beteiligt sind, desto größer wird die Fläche für fehlerhafte oder manipulierte Zwischenergebnisse, etwa wenn ein Tool kompromittierte oder fehlerhafte Daten zurückliefert und ein nachgelagerter Agent diese ungeprüft weiterverarbeitet. Guardrails sollten deshalb nicht nur am Anfang und Ende der gesamten Kette sitzen, sondern punktuell auch zwischen kritischen Handoffs, insbesondere dort, wo ein Agent Zugriff auf zahlungsrelevante oder personenbezogene Daten erhält. Rate Limiting auf Anwendungsebene, zusätzlich zu den von OpenAI vorgegebenen API-Limits, verhindert außerdem, dass ein einzelner fehlerhafter Client-Aufruf oder ein automatisierter Missbrauchsversuch unbemerkt hohe Kosten verursacht, bevor jemand eingreift.

Für deutsche und europäische Teams kommt ein weiterer Punkt hinzu, der bei reinen Funktionstests gern übersehen wird: die Frage, wo personenbezogene Daten tatsächlich verarbeitet werden und ob ein Auftragsverarbeitungsvertrag mit dem jeweiligen Modellanbieter vorliegt. Bevor ein Agent mit echten Kundendaten, Support-Tickets oder internen Dokumenten produktiv läuft, sollte diese Klärung abgeschlossen sein, nicht erst nach dem Launch. Das gilt unabhängig davon, ob am Ende GPT-6.1 Sol, GPT-6 Astra oder ein Modell eines anderen Anbieters zum Einsatz kommt.

Praxisbeispiele: Wofür Unternehmen Agenten mit GPT-6.1 Sol einsetzen

In der Praxis tauchen drei Einsatzmuster besonders häufig auf. Das erste ist der mehrstufige Support-Agent aus diesem Tutorial: Ein Agent nimmt die Anfrage entgegen, ein zweiter prüft Abrechnungsfragen, ein dritter eskaliert komplexe Fälle an Menschen. Das zweite Muster ist Agentencoding: GPT-6.1 Sol wird in Entwicklungsumgebungen wie Codex eingesetzt, um Dateien zu lesen, Tests auszuführen und kleinere Änderungen vorzuschlagen, abgesichert durch die native Sandbox-Ausführung des Agents SDK. Das dritte Muster betrifft Recherche- und Datenagenten, die über MCP-Server an interne Datenbanken oder Dokumentenablagen angebunden sind und strukturierte Zusammenfassungen liefern, statt Nutzer durch mehrere Systeme klicken zu lassen.

Ein viertes, zunehmend verbreitetes Muster ist die Qualitätssicherung von bestehenden Texten oder Konfigurationen durch einen spezialisierten Prüf-Agenten, der Ergebnisse eines ersten, produktiv arbeitenden Agenten noch einmal gegenprüft, bevor sie an einen Menschen oder ein nachgelagertes System weitergehen. Dieses Muster aus einem erzeugenden und einem prüfenden Agenten reduziert die Fehlerquote spürbar, kostet aber auch spürbar mehr, da praktisch jede Anfrage doppelt durch ein Modell läuft. Für Anwendungsfälle mit hohem Fehlerrisiko, etwa automatisch generierte Vertragsklauseln oder Code-Änderungen an produktiven Systemen, ist dieser Mehraufwand in der Regel gut investiert, für einfache FAQ-Antworten dagegen meist nicht.

Ein fünftes Muster betrifft interne Wissensdatenbanken, bei denen ein Agent Fragen zu Handbüchern, Richtlinien oder technischer Dokumentation beantwortet, ohne dass Mitarbeitende selbst in mehreren Systemen suchen müssen. In Kombination mit einem MCP-Server, der auf die entsprechende Dokumentenablage zugreift, lässt sich dieses Muster mit den Bausteinen aus diesem Tutorial direkt umsetzen, ohne zusätzliche Infrastruktur aufzubauen. Der entscheidende Unterschied zu einem klassischen Suchfeld liegt darin, dass der Agent mehrere Dokumente gleichzeitig berücksichtigen und die Antwort direkt zusammenfassen kann, statt nur eine Liste von Treffern zurückzugeben.

Gemeinsam ist allen drei Mustern, dass sie nicht auf das teuerste verfügbare Modell setzen, sondern bewusst zwischen Luna, Sol und Astra abwägen. Wer vergleichbare Benchmarks und Preisentwicklungen über die gesamte GPT-6-Familie verfolgen möchte, findet laufend aktualisierte Werte auf BenchLM, während sich Release-Details direkt bei den offiziellen OpenAI-Ankündigungen nachlesen lassen. Wer stattdessen lieber Benchmarks mehrerer Modelle selbst vergleichen will, bevor er sich für ein Modell entscheidet, kann das auch mit dem Setup aus unserem Tutorial zum selbst gehosteten LLM-Arena-Vergleich tun.

OpenAI selbst betont bei der Einordnung der neuen Agents-SDK-Fähigkeiten den praktischen Nutzen für Entwickler. Laut offizieller Ankündigung, über die unter anderem TheNextWeb berichtete, war GPT-6.1 Sol ab dem Veröffentlichungstag direkt für Plus-, Pro-, Business-, Enterprise- und Edu-Nutzer in ChatGPT Work und Codex verfügbar, ohne separate Wartezeit. Für Teams, die bereits mit der GPT-6-Familie experimentieren, verkürzt das den Weg von der Ankündigung zur eigenen Implementierung erheblich.

Häufig gestellte Fragen zum OpenAI Agents SDK

Ist das OpenAI Agents SDK kostenlos?

Das SDK selbst ist eine kostenlose, offene Python- und TypeScript-Bibliothek. Kosten entstehen ausschließlich durch die Nutzung der OpenAI-API, also durch Modellaufrufe und Tool-Nutzung nach Token-Preis.

Brauche ich für Agenten zwingend GPT-6 Astra?

Nein. GPT-6.1 Sol erreicht laut OpenAI nahezu dieselbe Qualität bei Agentencoding und Computer-Nutzung, kostet dabei aber nur ein Fünftel des Astra-Preises. Astra lohnt sich vor allem bei Aufgaben, die das große Kontextfenster von 1,05 Millionen Tokens oder die höchste verfügbare Zuverlässigkeit bei grafischer Bedienung erfordern.

Funktioniert das Agents SDK auch mit anderen Modellanbietern?

Das SDK ist auf die OpenAI-Modelle zugeschnitten. Für Multi-Provider-Szenarien mit Modellen anderer Anbieter setzen viele Teams zusätzlich eine Abstraktionsschicht ein oder wechseln je nach Aufgabe komplett das Framework, etwa zu LangGraph oder CrewAI.

Wie unterscheidet sich ein Handoff von einem einfachen Funktionsaufruf?

Ein Funktionsaufruf liefert ein Ergebnis an denselben Agenten zurück, der ihn ausgelöst hat. Ein Handoff übergibt die gesamte weitere Konversation an einen anderen Agenten mit eigener Instruktion, eigenem Modell und eigenen Tools.

Sind Agenten mit Computer-Use-Zugriff sicher genug für den produktiven Einsatz?

Sie können es sein, aber nicht ohne zusätzliche Schutzmaßnahmen. Sowohl OpenAIs als auch Anthropics Ansätze setzen auf kontrollierte Umgebungen und Entwicklerverantwortung bei der Ausführung. Destruktive oder finanzielle Aktionen sollten grundsätzlich eine menschliche Bestätigung durchlaufen, bevor sie ausgeführt werden.

Wie teste ich, wie viele Tokens ein Agentenlauf tatsächlich verbraucht?

Über das eingebaute Tracing des Agents SDK lässt sich jeder Lauf einzeln einsehen, inklusive aller Modell- und Tool-Aufrufe. Das ist zuverlässiger als eine Schätzung auf Basis der Prompt-Länge, weil Zwischenschritte wie Tool-Aufrufe oder Handoffs oft zusätzliche, leicht übersehene Modellaufrufe erzeugen.

Kann ich mehrere Sessions parallel für verschiedene Nutzer verwalten?

Ja, solange jeder Nutzer eine eigene, feste Session-ID erhält. Im Beispiel aus Schritt 12 übernimmt ein einfaches Dictionary diese Zuordnung. Für Produktionssysteme empfiehlt sich stattdessen ein externer Speicher wie Redis oder Postgres.

Was kostet ein Agent mit GPT-6.1 Sol im Monat ungefähr?

Das hängt stark vom Anfragevolumen und der Zahl der Zwischenschritte ab. Bei 10.000 Anfragen im Monat mit rund 500 Input- und 150 Output-Token je Anfrage liegen die reinen Modellkosten für GPT-6.1 Sol überschlägig bei 25 Dollar monatlich. Jeder zusätzliche Tool-Aufruf oder Handoff erzeugt einen weiteren Modellaufruf und erhöht die Kosten entsprechend, weshalb sich eine Prüfung über das eingebaute Tracing lohnt, bevor ein Agent in großem Stil produktiv geschaltet wird.

GPT-6.1-Sol-Agent bauen: 12 Schritte, 80% günstiger [2026]