Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Mehrschrittiger Agent mit Nachdenkschleife

Lektion 15 von 25 Aktualisiert am 29. Juli 2026 Entwickler
Auf dieser Seite
  1. Mehrschrittiger Agent mit Nachdenkschleife
  2. Das Plan-Ausführen-Muster
  3. Selbstkorrigierender Agent
  4. Muster: Kette spezialisierter Agenten
  5. Steuerung der Nachdenktiefe
  6. Kernaussagen

Mehrschrittiger Agent mit Nachdenkschleife

Die leistungsfähigsten Agenten stoppen nicht nach einer einzigen Werkzeuganfrage. Sie verketten mehrere Nachdenkschritte, passen ihre Strategie basierend auf den Ergebnissen an und iterieren, bis sie ihr Ziel erreichen. In dieser Lektion erfahren Sie, wie Sie diese mehrschrittigen Agenten erstellen. Die Beispiele verwenden die GPT-5.6-Familie: Während die vorherige Generation ein Wechseln der Modelle erforderte, um Nachdenken zu aktivieren, steuern Sie dieses Verhalten nun über die Einstellung effort Ihres gewählten Modells.

Das Plan-Ausführen-Muster

Ein mehrschrittiger Agent beginnt mit der Erstellung eines Plans und führt dann jeden Schritt aus. Diese Trennung ist absichtlich: Der Planer verfügt über keine Werkzeuge und erzeugt eine typisierte Struktur, während der Ausführer diesen Plan als Fahrplan erhält und ihn einfach befolgt. Eine vage Anfrage wie „Vorbereitung der Quartalsüberprüfung für Schlüsselkonten” wird zu einer konkreten Abfolge von Aktionen – CRM abfragen, Bericht generieren, E-Mail senden – bevor überhaupt eine Aktion versucht wird.

from agents import Agent, Runner, function_tool
from pydantic import BaseModel
import json

class PlanAction(BaseModel):
    steps: list[str]
    objective: str

planner_agent = Agent(
    name="Planner",
    instructions="""Sie erhalten eine komplexe Aufgabe. Zerlegen Sie diese in einfache, geordnete Schritte.
    Jeder Schritt muss ein konkretes, ausführbares Element sein.""",
    model="gpt-5.6-sol",  # Erweitertes Nachdenken für die Planung
    output_type=PlanAction,
)

@function_tool
def search_crm(query: str) -> str:
    """Sucht im CRM nach Kundeninformationen."""
    return json.dumps({"customers": [
        {"name": "Acme Corp", "revenue": 500000, "contract": "Enterprise"},
        {"name": "TechStart", "revenue": 50000, "contract": "Starter"},
    ]})

@function_tool
def generate_report(title: str, content: str) -> str:
    """Generiert einen formatierten Bericht."""
    return f"Bericht '{title}' erfolgreich generiert ({len(content)} Zeichen)"

@function_tool
def send_email(recipient: str, subject: str, body: str) -> str:
    """Sendet eine E-Mail."""
    return f"E-Mail an {recipient} gesendet: {subject}"

executor_agent = Agent(
    name="Executor",
    instructions="""Sie führen Aufgaben Schritt für Schritt aus.
    Verwenden Sie verfügbare Werkzeuge, um jeden Schritt abzuschließen.
    Wenn ein Schritt fehlschlägt, versuchen Sie einen alternativen Ansatz.""",
    tools=[search_crm, generate_report, send_email],
    model="gpt-5.6-terra",
)

async def process_complex_task(task: str):
    # Schritt 1: Planen
    plan = await Runner.run(planner_agent, task)
    print(f"Plan: {plan.final_output.steps}")

    # Schritt 2: Ausführen mit dem Plan als Kontext
    execution_instructions = f"""Führen Sie die folgenden Schritte in der angegebenen Reihenfolge aus:
    {chr(10).join(f'{i+1}. {e}' for i, e in enumerate(plan.final_output.steps))}
    Ziel: {plan.final_output.objective}"""

    result = await Runner.run(executor_agent, execution_instructions)
    return result.final_output

Selbstkorrigierender Agent

Nur das Planen reicht nicht: In der realen Welt versagen Werkzeuge. Die zweite Form der Schleife ermöglicht es dem Agenten, seine eigenen Fehler zu erkennen und zu korrigieren. Alles hängt von einem Detail ab, das oft übersehen wird: Das Werkzeug wirft keine Ausnahme, sondern gibt eine lesbare Fehlermeldung zurück. Der Agent liest diese, erkennt, dass er die FROM-Klausel vergessen hat, schreibt seine Abfrage um und versucht erneut, innerhalb des von seinen Anweisungen festgelegten Limits von drei Versuchen.

from agents import Agent, Runner, function_tool

@function_tool
def execute_sql_query(sql: str) -> str:
    """Führt eine SQL-Abfrage in der Datenbank aus."""
    # Simulation: Manche Abfragen versagen
    if "DROP" in sql.upper():
        return "ERROR: Zerstörende Abfragen sind verboten."
    if "SELECT" in sql.upper() and "FROM" not in sql.upper():
        return "ERROR: Ungültige SQL-Syntax - fehlende FROM-Klausel."
    return json.dumps({
        "columns": ["name", "monthly_revenue", "region"],
        "rows": [
            ["Acme Corp", 45000, "Île-de-France"],
            ["TechStart", 12000, "Rhône-Alpes"],
        ],
        "result_count": 2
    })

analyst_agent = Agent(
    name="Datenanalyst",
    instructions="""Sie analysieren Daten, indem Sie SQL-Abfragen ausführen.
    Wenn eine Abfrage fehlschlägt:
    1. Analysieren Sie die Fehlermeldung
    2. Korrigieren Sie die Abfrage
    3. Versuchen Sie erneut
    Maximale 3 Versuche pro Abfrage.
    Verwenden Sie niemals DROP, DELETE oder TRUNCATE.""",
    tools=[execute_sql_query],
    model="gpt-5.6-terra",
    max_turns=10,  # Genug Runden für Korrekturen
)

result = Runner.run_sync(
    analyst_agent,
    "Was ist die Gesamtumsatz nach Regionen?"
)

Beachten Sie, dass das Verbot zerstörender Abfragen an zwei Stellen erscheint: in den Anweisungen und im Werkzeugcode. Die Anweisung leitet das Modell, aber nur die serverseitige Prüfung im Werkzeug garantiert, dass eine DROP TABLE-Anweisung niemals durchrutscht.

Muster: Kette spezialisierter Agenten

Für komplexe Workflows verketten Sie mehrere spezialisierte Agenten, anstatt einen einzelnen Agenten mit jeder Verantwortung zu belasten. Jedes Glied hat eine klare Rolle: Der Sammler holt das Rohmaterial, der Analyst – ausgestattet mit einem Nachdenkmodell – identifiziert Trends, und der Schreiber formatiert die Ausgabe. Der Vorteil ist sowohl pädagogischer als auch operativer: Wenn der endgültige Bericht enttäuscht, wissen Sie sofort, welchen der drei Agenten Sie reparieren müssen.

from agents import Agent, Runner

collection_agent = Agent(
    name="Datensammler",
    instructions="Sammeln Sie alle Daten, die für die Analyse notwendig sind.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)

analysis_agent = Agent(
    name="Analyst",
    instructions="Analysieren Sie die gesammelten Daten und identifizieren Sie Trends.",
    model="gpt-5.6-sol",  # Erweitertes Nachdenken für die Analyse
)

writing_agent = Agent(
    name="Schreiber",
    instructions="""Schreiben Sie einen klaren, strukturierten Bericht auf Englisch
    basierend auf der bereitgestellten Analyse. Format: Einleitung, Hauptpunkte, Empfehlungen.""",
    model="gpt-5.6-terra",
)

async def analysis_pipeline(question: str):
    # Schritt 1: Daten sammeln
    data = await Runner.run(collection_agent, question)

    # Schritt 2: Analysieren
    analysis = await Runner.run(
        analysis_agent,
        f"Analysieren Sie diese Daten: {data.final_output}"
    )

    # Schritt 3: Bericht schreiben
    report = await Runner.run(
        writing_agent,
        f"Schreiben Sie einen Bericht basierend auf dieser Analyse: {analysis.final_output}"
    )

    return report.final_output

Steuerung der Nachdenktiefe

Alle diese Schleifen haben ein gemeinsames Merkmal: Sie könnten niemals aufhören. Der Parameter max_turns ist Ihre primäre Schutzmaßnahme, und Sie passen ihn basierend auf dem Anspruch der Aufgabe an. Drei Runden reichen für einen Agenten, der erwartet wird, die Antwort beim ersten Versuch zu liefern; für eine Erkundung, die mehrere Quellen abfragt, bevor sie zu einem Schluss kommt, sind zwanzig-fünf Runden notwendig.

# Konservativer Agent: wenige Runden
simple_agent = Agent(
    name="Einfacher Agent",
    instructions="Beantworten Sie in einer einzigen Runde, wenn möglich.",
    model="gpt-5.6-terra",
)
result = await Runner.run(simple_agent, "Einfache Frage", max_turns=3)

# Komplexer Agent: viele Runden
research_agent = Agent(
    name="Tiefenforscher",
    instructions="Erforschen Sie alle Winkel, bevor Sie zu einem Schluss kommen.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)
result = await Runner.run(research_agent, "Vollständige Q1-Analyse", max_turns=25)

Legen Sie diesen Wert fest, indem Sie Ihre Spuren beobachten, statt zu raten: Wenn Ihre tatsächlichen Ausführungen in sechs Runden abgeschlossen sind, schützt ein Limit von zwanzig-fünf vor nichts.

Kernaussagen

  • Das Plan-Ausführen-Muster trennt Planung (Nachdenkmodell) von der Ausführung
  • Ein selbstkorrigierender Agent analysiert seine Fehler und passt seine Strategie an
  • Ketten spezialisierter Agenten ermöglichen komplexe, wartbare Workflows
  • max_turns steuert die Nachdenktiefe und schützt vor unendlichen Schleifen
  • Bewahren Sie erweiterte Nachdenkfähigkeiten für Planung und Analyse vor