Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Agent-Architektur: Der Werkzeug-Reasoning-Loop

Lektion 2 von 25 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Agent-Architektur: Der Werkzeug-Reasoning-Loop
  2. Der Agenten-Lebenszyklus
  3. Interne Struktur: Items und Nachrichten
  4. Parallele vs. sequenzielle Aufrufe
  5. Der Parameter max_turns
  6. Kernaussagen

Aktualisiert am 3. November 2026: In rechercher_produit fehlten den Schlüsseln prix und stock die Anführungszeichen, was beim ersten Werkzeugaufruf einen NameError verursachte.

Agent-Architektur: Der Werkzeug-Reasoning-Loop

Um wirksame Agenten zu entwickeln, müssen Sie deren interne Architektur verstehen. Ein OpenAI-Agent arbeitet nach einem Reasoning-Loop: Er erhält eine Aufgabe, denkt nach, nutzt ein Werkzeug, beobachtet das Ergebnis und entscheidet dann, ob er fertig ist oder fortzufahren hat. Alles, was Sie danach tun – Werkzeuge deklarieren, Sicherheitsvorkehrungen festlegen, mehrere Agenten orchestrieren – baut auf diesem Loop auf.

Der Agenten-Lebenszyklus

Jede Ausführung folgt sechs Schritten:

  1. Empfang: Der Agent erhält die Benutzeranfrage und die Systemanweisungen.
  2. Reasoning: Das Modell analysiert die Anfrage und entscheidet sich für die nächste Aktion.
  3. Werkzeugaufruf: Der Agent ruft bei Bedarf ein oder mehrere Werkzeuge auf.
  4. Beobachtung: Der Agent erhält die Ergebnisse der Werkzeuge.
  5. Entscheidung: Der Agent entscheidet, ob er fortfahren soll (Rückkehr zu Schritt 2) oder antworten soll.
  6. Antwort: Der Agent liefert seine endgültige Antwort.

Der Schlüssel liegt im Loop zwischen Schritt 2 und 5, der sich mehrfach wiederholen kann. Ein Agent kann 5, 10 oder sogar 20 Werkzeugaufrufe hintereinander ausführen, bevor er eine endgültige Antwort liefert, ohne dass Sie eine einzige Zeile Orchestrierungscode schreiben müssen. Das folgende Beispiel zeigt dies: Zwei unabhängige Werkzeuge werden deklariert, und das Modell entscheidet, wie es sie verknüpft.

from agents import Agent, Runner, function_tool

@function_tool
def rechercher_produit(nom: str) -> str:
    """Sucht ein Produkt im Katalog."""
    # Simulation - in der Produktion wird Ihre Datenbank aufgerufen
    catalogue = {
        "laptop-pro": {"prix": 1299, "stock": 45},
        "tablet-air": {"prix": 599, "stock": 120},
    }
    produit = catalogue.get(nom)
    if produit:
        return f"Produit {nom}: {produit['prix']}€, stock: {produit['stock']}"
    return f"Produit {nom} nicht gefunden"

@function_tool
def calculer_remise(prix: float, pourcentage: float) -> str:
    """Berechnet den Preis nach Rabatt."""
    prix_final = prix * (1 - pourcentage / 100)
    return f"Prix après {pourcentage}% de remise : {prix_final:.2f}€"

agent = Agent(
    name="Sales Agent",
    instructions="Sie helfen Kunden, Produkte zu finden und Rabatte zu berechnen.",
    tools=[rechercher_produit, calculer_remise],
    model="gpt-5.6-terra",
)

# Der Agent wird: 1) das Produkt finden, 2) den Rabatt berechnen, 3) antworten
result = Runner.run_sync(
    agent,
    "Was kostet das laptop-pro mit einem 15% Rabatt?"
)
print(result.final_output)

Die Anfrage erfordert zwei Operationen, die im Code nicht explizit verknüpft sind. Der Agent führt automatisch zwei Werkzeugaufrufe nacheinander aus: zuerst rechercher_produit, dann calculer_remise mit dem abgerufenen Preis. Diese Verkettung ist eine Entscheidung des Modells, keine Ihrer Anweisungen.

Interne Struktur: Items und Nachrichten

Die Responses API strukturiert jede Interaktion als Items. Durch das Lesen dieser Items können Sie nachvollziehen, was Ihr Agent tatsächlich getan hat. Im Gespräch erscheinen drei Typen:

  • message: Eine Textnachricht (vom Benutzer oder vom Agenten)
  • function_call: Ein Werkzeugaufruf, der vom Agenten entschieden wurde
  • function_call_output: Das Ergebnis, das das Werkzeug zurückgibt
result = Runner.run_sync(agent, "Find the tablet-air")

# Inspektion der Reasoning-Schritte
for item in result.raw_responses:
    print(f"Type: {type(item).__name__}")
    # Sie werden sehen: message input → function_call → function_call_output → message output

Machen Sie es zur Gewohnheit, diesen Loop zu verfolgen, wenn ein Agent eine überraschende Antwort liefert. Neunmal von zehnmal zeigt sich die Anomalie in einem function_call mit unerwarteten Argumenten.

Parallele vs. sequenzielle Aufrufe

Nicht alle Schritte sind voneinander abhängig. Wenn zwei Aufrufe unabhängig sind, kann der Agent entscheiden, sie parallel auszuführen.

@function_tool
def obtenir_meteo(ville: str) -> str:
    """Holt die aktuelle Wetterlage für eine Stadt."""
    meteos = {"Paris": "18°C, sonnig", "Lyon": "16°C, bewölkt"}
    return meteos.get(ville, "Daten nicht verfügbar")

agent = Agent(
    name="Travel Agent",
    instructions="Sie helfen bei der Reiseplanung.",
    tools=[obtenir_meteo, rechercher_produit],
    model="gpt-5.6-terra",
)

# Der Agent wird obtenir_meteo("Paris") und obtenir_meteo("Lyon") parallel aufrufen
result = Runner.run_sync(
    agent,
    "Wie ist das Wetter in Paris und Lyon?"
)

Das Wetter in Lyon hängt nicht vom Wetter in Paris ab: Das SDK verwaltet die Parallelität automatisch und startet beide Aufrufe gleichzeitig, was die Latenz reduziert. Vergleichen Sie dies mit dem obigen Beispiel für den Verkauf, bei dem die Rabattberechnung auf den Preis warten musste: Dort ergibt sich die Sequenz von selbst.

Der Parameter max_turns

Ein autonomer Loop kann im schlimmsten Fall niemals stoppen: Der Agent ruft ein Werkzeug auf, das Ergebnis führt dazu, dass er ein anderes aufruft, und so weiter. Die Sicherheitsvorkehrung ist ein einzelner Parameter.

result = Runner.run_sync(
    agent,
    "Vollständige Kataloganalyse",
    max_turns=10  # Maximale 10 Loop-Iterationen
)

Wenn der Agent das Limit erreicht, stoppt er mit den bisher erhaltenen Ergebnissen. In der Produktion ist dies eine wesentliche Sicherheitsmaßnahme: Er begrenzt sowohl die Antwortzeit als auch die Kosten.

Kernaussagen

  • Ein Agent läuft in einem Loop: Reasoning → Werkzeug → Beobachtung → Entscheidung
  • Dieser Loop kann sich mehrfach ausführen, bevor eine Antwort generiert wird
  • Das Modell entscheidet automatisch, welche Werkzeuge aufgerufen werden und in welcher Reihenfolge
  • Unabhängige Werkzeugaufrufe werden parallel ausgeführt
  • max_turns begrenzt die Anzahl der Iterationen zur Sicherheit