Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Automatisierung mehrstufiger Workflows

Lektion 9 von 14 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Orchestrierung komplexer Aufgaben
  2. Schritt-basierte Architektur
  3. Der Orchestrator
  4. Datenübertragung zwischen Schritten
  5. Konditionelle Workflows
  6. Parallelisierung
  7. Kernaussagen

Lektion aktualisiert am 3. November 2026 gemäß den Integrationsrichtlinien von OpenAI für Computer Use: Der Agent führt keine Anmeldungen mehr durch; die Validierung von Befehlen und Zweige, die den Benutzer binden (z. B. Bewertungen, neue Bestellungen), erfordern eine menschliche Bestätigung; der Orchestrator prüft nun das Kriterium success_text_contains, das er zuvor ignorierte, markiert fehlgeschrittene Schritte anstatt sie zu überspringen und wiederholt niemals einen Schritt, der Daten erstellt. Quelle: Bestätigung und Zustimmung.

Orchestrierung komplexer Aufgaben

Echte Workflows bestehen selten aus einer einzigen Aktion. Das Belegen eines CRM erfordert das Navigieren zwischen Seiten, das Finden eines Kontakts, das Aktualisieren seiner Informationen und schließlich die Erstellung einer Opportunity – vier verkettete Operationen, die jeweils aus eigenem Grund fehlschlagen können. Die Übergabe dieses gesamten Blocks an einen Agenten in einer einzigen Prompt funktioniert manchmal, aber Sie werden nie wissen, wo genau es ausgefallen ist. In dieser Lektion lernen Sie, diese mehrstufigen Automatisierungen so zu strukturieren, dass jeder Link beobachtbar und wiederholbar ist.

Schritt-basierte Architektur

Beginnen Sie damit, den Workflow in atomare Schritte zu zerlegen, wobei jeder Schritt ein klares Ziel und ein Erfolgskriterium hat. Dieses Kriterium unterscheidet eine To-Do-Liste von einem echten Workflow: Ohne es kann der Orchestrator nicht feststellen, ob der Agent tatsächlich erfolgreich war oder auf einer Fehlerseite stehen geblieben ist. Im folgenden Beispiel wird das Öffnen des Moduls durch die URL verifiziert, und die Suche durch das Vorhandensein des Namens des Kontakts auf dem Bildschirm. Die Anmeldung ist hier nicht enthalten: Ihr Code hat dies zuvor ohne Offenlegung des Passworts für das Modell erledigt (Lektion 8). Der letzte Schritt hat "retry": False, da er Daten erstellt: Eine Wiederholung nach einem teilweisen Fehler könnte eine Duplizierung verursachen.

workflow = [
    {
        "name": "open_contacts",
        "task": "Öffnen Sie das Kontakte-Modul im CRM.",
        "success_url_contains": "/contacts",
    },
    {
        "name": "search_contact",
        "task": "Suchen Sie den Kontakt 'Jean Dupont' in der Suchleiste.",
        "success_text_contains": "Jean Dupont",
    },
    {
        "name": "update_record",
        "task": "Öffnen Sie das Profil von Jean Dupont und aktualisieren Sie deren Telefonnummer: 06 98 76 54 32.",
    },
    {
        "name": "create_opportunity",
        "task": "Erstellen Sie eine Opportunity: 'Cloud Migration Q2 2026', Betrag 50000 EUR, Wahrscheinlichkeit 60%.",
        "retry": False,  # nicht wiederholbarer Schritt: erstellt Daten
    },
]

Der Orchestrator

Nun müssen Sie diese Liste ausführen. Der Orchestrator durchläuft die Schritte sequentiell und umgibt jeden mit einer Wiederholungs-Schleife: Ein Schritt, der eine Ausnahme wirft oder sein Erfolgskriterium nicht erfüllt, wird bis zu max_retries Mal wiederholt, es sei denn, er ist als nicht wiederholbar markiert. Dieses Detail ist in der Produktion wichtig, da viele visuelle Agentenfehler vorübergehend sind – eine langsame Seite, ein unvollständiges Rendering zum Zeitpunkt des Screenshots. Ein Schritt, der definitiv fehlschlägt, stoppt den Workflow, da nachfolgende Schritte davon abhängen. Schließlich gibt der Orchestrator ein strukturiertes Protokoll zurück, das für jeden Schritt seinen Status und die Anzahl der verbrauchten Versuche angibt: Ihr erstes Diagnosewerkzeug.

def run_workflow(workflow: list, page, max_retries: int = 2):
    """Führt einen mehrstufigen Workflow mit Wiederholungen aus."""
    results = []

    for step in workflow:
        step_name = step["name"]
        print(f"\n--- Schritt: {step_name} ---")
        attempts = max_retries + 1 if step.get("retry", True) else 1
        error = "Erfolgskriterium nicht erfüllt"

        for attempt in range(attempts):
            try:
                run_agent(step["task"], page=page)

                # Optionale Prüfungen: URL, dann sichtbarer Text
                url_check = step.get("success_url_contains")
                if url_check and url_check not in page.url:
                    print("  Erwartete URL nicht gefunden")
                    continue
                text_check = step.get("success_text_contains")
                if text_check and text_check not in page.locator("body").inner_text():
                    print("  Erwarteter Text nicht gefunden")
                    continue

                print(f"  Erfolg (Versuch {attempt + 1})")
                results.append({"step": step_name, "status": "success", "attempts": attempt + 1})
                break

            except Exception as e:
                print(f"  Fehler: {e}")
                error = str(e)
        else:
            # Kein Versuch war erfolgreich: nachfolgende Schritte hängen davon ab
            results.append({"step": step_name, "status": "failed", "error": error})
            break

    return results

Datenübertragung zwischen Schritten

Oft produziert ein Schritt Daten, die vom nächsten benötigt werden: Der Preis auf einer Warenkorbseite muss am Kassen-Schritt verifiziert werden; die Fallnummer, die in Schritt 2 erstellt wurde, dient als Referenz in Schritt 5. Ein gemeinsamer Kontext löst dieses Bedürfnis, ohne Ihren Code in ein Gewirr globaler Variablen zu verwandeln. Das folgende Beispiel stoppt absichtlich vor der Zahlung: OpenAI klassifiziert die Bestätigung einer finanziellen Transaktion als Aktion, die eine Benutzervalidierung zum Zeitpunkt der Ausführung erfordert. Die Klasse unten speichert Schlüssel-Wert-Paare und stellt eine inject-Methode bereit, die {key}-Marker in einer Prompt-Vorlage ersetzt, sodass Sie Ihre Aufgaben als parametrisierte Vorlagen schreiben können.

class WorkflowContext:
    """Speichert Daten, die zwischen Schritten geteilt werden."""

    def __init__(self):
        self.data = {}

    def set(self, key: str, value):
        self.data[key] = value

    def get(self, key: str, default=None):
        return self.data.get(key, default)

    def inject(self, template: str) -> str:
        """Ersetzt {key}-Variablen in der Vorlage."""
        task = template
        for key, value in self.data.items():
            task = task.replace("{" + key + "}", str(value))
        return task


# Beispiel für die Verwendung
ctx = WorkflowContext()

# Schritt 1: Agent liest einen Preis
extracted_price = run_agent(
    "Lesen Sie den angezeigten Gesamtpreis und geben Sie nur die Zahl zurück.",
    page=page
)
ctx.set("price", extracted_price.strip())

# Schritt 2: Agent überprüft, ohne etwas zu validieren
verdict = run_agent(ctx.inject(
    "Der erwartete Betrag ist {price} EUR. Vergleichen Sie ihn mit dem Gesamtbetrag auf der Zahlungsseite "
    "und antworten Sie nur OK oder MISMATCH. Validieren Sie nichts."
), page=page)

# Schritt 3: Eine Transaktion wird zum Zeitpunkt der Aktion durch einen Menschen bestätigt
if verdict.strip() == "OK":
    if input(f"Bestellen Sie für {ctx.get('price')} EUR? [j/N] ").strip().lower() == "j":
        run_agent("Klicken Sie auf den Bestätigungsknopf für die Bestellung.", page=page)

Konditionelle Workflows

Lineare Sequenzen stoßen schnell an ihre Grenzen, da der nächste Schritt vom vorherigen Ergebnis abhängen kann. Das zu merkende Muster lautet wie folgt: Fragen Sie zuerst den Agenten, einen Zustand zu lesen, indem Sie ihn daran beschränken, mit einem Wert aus einer geschlossenen Menge zu antworten, und verzweigen Sie dann in Python. Für die Auftragsverfolgung führt ein Status “in Bearbeitung” zur Paketverfolgung, “geliefert” zur Abrufung des Lieferdatums und “storniert” zur Abrufung des Grundes. Formatbeschränkungen im Prompt sind unerlässlich: Ohne sie gibt der Agent einen Satz zurück, den Ihre Vergleiche regelmäßig übersehen. Alle drei Zweige bleiben schreibgeschützt: Das Posten einer Bewertung oder das Neuordern würde den Benutzer binden und seine Bestätigung erfordern.

def conditional_workflow(page):
    """Workflow mit bedingter Verzweigung."""
    # Schritt 1: Status lesen
    status = run_agent(
        "Lesen Sie den Auftragsstatus. "
        "Geben Sie nur zurück: in Bearbeitung, geliefert oder storniert.",
        page=page
    )

    # Verzweigen basierend auf dem Ergebnis
    match status.strip().lower():
        case "in bearbeitung":
            return run_agent("Klicken Sie auf 'Paket verfolgen' und notieren Sie den angezeigten Status.", page=page)
        case "geliefert":
            return run_agent("Notieren Sie das angezeigte Lieferdatum.", page=page)
        case "storniert":
            return run_agent("Notieren Sie den angezeigten Stornierungsgrund.", page=page)
        case _:
            raise ValueError(f"Unerwarteter Status: {status!r}")

Parallelisierung

Wenn Aufgaben unabhängig sind, besteht kein Bedarf, sie sequentiell zu verarbeiten. Das Extrahieren von Daten aus drei Produktdatenblättern dauert viel weniger Zeit, wenn drei Agenten gleichzeitig arbeiten, jeder in seinem eigenen Tab. Die asynchrone Version von Playwright und asyncio.gather reichen aus: eine Coroutine pro URL, eine new_page pro Coroutine und eine systematische Schließung der Seiten, um das Ansammeln von Tabs im Arbeitsspeicher zu vermeiden. run_agent_async ist der Schleifenmechanismus aus Lektion 4, neu geschrieben mit dem AsyncOpenAI-Client und der asynchronen API von Playwright: dieselbe Logik, jedoch mit await vor jedem Aufruf. Denken Sie daran, dass Parallelisierung auch Ihren API-Aufruf-Durchsatz vervielfacht, was das Risiko erhöht, Ihre Rate-Limits zu erreichen (Lektion 11), und die Last auf der Zielseite – drei Tabs gehen unbemerkt, fünfzig viel weniger.

import asyncio
from playwright.async_api import async_playwright

async def parallel_extraction(urls: list[str]):
    """Extrahiert Daten aus mehreren Seiten parallel."""
    async with async_playwright() as pw:
        browser = await pw.chromium.launch(headless=True)

        async def extract_one(url: str):
            page = await browser.new_page(
                viewport={"width": 1280, "height": 720}
            )
            try:
                await page.goto(url)
                result = await run_agent_async(
                    "Extrahieren Sie den Produkttitel und den Preis.", page=page
                )
            finally:
                await page.close()
            return {"url": url, "data": result}

        results = await asyncio.gather(
            *[extract_one(url) for url in urls]
        )

    return results

# Ausführung
urls = [
    "https://shop.example.com/product/1",
    "https://shop.example.com/product/2",
    "https://shop.example.com/product/3",
]
data = asyncio.run(parallel_extraction(urls))

Kernaussagen

  • Zerlegen Sie Workflows in atomare Schritte mit expliziten Erfolgskriterien.
  • Wiederholen Sie automatisch Schritte, die sicher erneut ausgeführt werden können, niemals solche, die Daten erstellen.
  • Verwenden Sie einen gemeinsamen Kontext, um Daten zwischen Schritten zu übermitteln.
  • Konditionelle Workflows passen sich dem Seiteninhalt an; Zweige, die den Benutzer binden, erfordern seine Bestätigung.
  • Parallelisieren Sie unabhängige Aufgaben, um Zeit zu sparen.