Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Erster Workflow: Navigieren und Interagieren

Lektion 4 von 14 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Die Bausteine zusammenfügen
  2. Der Aktionshandler
  3. Der vollständige Zyklus
  4. Workflow starten
  5. Eine wiederverwendbare Funktion für den Rest des Kurses
  6. Drei Fehler, die Sie begegnen werden
  7. Kernaussagen

Lektion am 3. November 2026 neu geschrieben basierend auf OpenAIs Computer use-Guide und Computer use integration recipes: Der Agent nutzt das computer-Tool aus der Responses API, einen Aktionshandler, der an der Dokumentation modelliert ist (gruppierte Aktionen, keypress, scroll_x/scroll_y, drag-Pfade), und eine Verkettung über previous_response_id, anstatt Code, der für die Anthropic API geschrieben wurde. Quellen: Computer use · Integration recipes.

Die Bausteine zusammenfügen

Sie haben den Zyklus im Kopf und die Umgebung ist konfiguriert. Jetzt müssen Sie sie zu einem funktionierenden Programm zusammenfügen: einem Agenten, der eine Online-Enzyklopädie öffnet, nach einem Begriff sucht, das erste Ergebnis öffnet und den Titel der erreichten Seite meldet. Das Szenario scheint bescheiden, aber es greift auf die grundlegenden Gesten zurück – Navigation, Tippen, Klicken, Lesen von Informationen – und alles, was Sie im Folgenden bauen, wird nur eine längere Variante davon sein.

Der Aktionshandler

Das Modell entscheidet, führt aber nichts selbst aus: Es gibt eine Liste von Aktionen zurück, und Ihr Code übersetzt diese in Playwright-Gesten, nacheinander. Diese Funktion folgt dem Handler, den OpenAI in seinen Integrationsrezepten veröffentlicht hat, vereinfacht für einen Browser.

import time

KEYS = {
    "ENTER": "Enter", "RETURN": "Enter", "ESC": "Escape", "ESCAPE": "Escape",
    "TAB": "Tab", "SPACE": "Space", "BACKSPACE": "Backspace", "DELETE": "Delete",
    "UP": "ArrowUp", "DOWN": "ArrowDown", "LEFT": "ArrowLeft", "RIGHT": "ArrowRight",
    "CTRL": "Control", "CONTROL": "Control", "SHIFT": "Shift", "ALT": "Alt",
    "CMD": "Meta", "META": "Meta",
}
BUTTONS = {"left": "left", "right": "right", "wheel": "middle"}

def execute_actions(page, actions):
    """Führt die Aktionen aus einem computer_call nacheinander aus."""
    for action in actions:
        if action.type in ("click", "double_click", "drag", "move", "scroll") and getattr(action, "keys", None):
            raise ValueError("Mausaktion mit Modifikator-Taste: wird hier nicht unterstützt")
        match action.type:
            case "click":
                button = getattr(action, "button", "left")
                if button not in BUTTONS:  # Zurück- und Vorwärts-Tasten existieren nicht in Playwright
                    raise ValueError(f"Unsupportierte Taste: {button}")
                page.mouse.click(action.x, action.y, button=BUTTONS[button])
            case "double_click":
                page.mouse.dblclick(action.x, action.y)
            case "drag":
                points = [(p.x, p.y) for p in action.path]
                page.mouse.move(*points[0])
                page.mouse.down()
                for x, y in points[1:]:
                    page.mouse.move(x, y)
                page.mouse.up()
            case "move":
                page.mouse.move(action.x, action.y)
            case "scroll":
                page.mouse.move(action.x, action.y)
                page.mouse.wheel(action.scroll_x, action.scroll_y)
            case "keypress":
                page.keyboard.press("+".join(KEYS.get(k, k) for k in action.keys))
            case "type":
                page.keyboard.type(action.text)
            case "wait":
                time.sleep(2)
            case "screenshot":
                continue  # Screenshot wird nach jeder Batch-Aktion aufgenommen
            case _:
                raise ValueError(f"Unsupportierte Aktion: {action.type}")

Zwei Entscheidungen verdienen eine Erklärung. Die Tasten- und Tastenname, die vom Modell zurückgegeben werden (ENTER, CTRL, wheel…), entsprechen nicht dem, was Playwright erwartet (Enter, Control, middle…): Die Abbildungstabellen, die aus der Dokumentation stammen, überbrücken diese Lücke, und die back- und forward-Tasten, die die API ebenfalls anfordern kann, werden abgelehnt, wie im OpenAI-Handler. Und eine unbekannte Aktion löst einen Fehler aus, statt stumm ignoriert zu werden: Ein harter Stopp ist besser als ein Agent, der denkt, er habe gehandelt, obwohl er es nicht getan hat.

Der vollständige Zyklus

Der Agent orchestriert dann den Zyklus. Der erste Aufruf sendet die Aufgabe; wenn er nur eine Screenshot-Anforderung enthält, geben Sie einfach den Bildschirm zurück. Jeder Screenshot kommt als Ergebnis des Aufrufs zurück, der ihn angefordert hat, referenziert durch seine call_id, und previous_response_id verknüpft die Runden miteinander.

import base64

from openai import OpenAI
from playwright.sync_api import sync_playwright

client = OpenAI()
MODEL = "gpt-6.1-sol"
MAX_TURNS = 15

def launch_agent(task: str, start_url: str = "https://en.wikipedia.org"):
    """Startet einen Computer Use Agenten für eine gegebene Aufgabe."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=False)  # False zur Beobachtung
    page = browser.new_page(viewport={"width": 1280, "height": 720})
    page.goto(start_url)
    page.wait_for_load_state("networkidle")

    try:
        response = client.responses.create(
            model=MODEL, tools=[{"type": "computer"}], input=task,
        )
        for turn in range(MAX_TURNS):
            call = next((i for i in response.output if i.type == "computer_call"), None)
            if call is None:
                print(f"Aufgabe abgeschlossen: {response.output_text}")
                return response.output_text

            if call.pending_safety_checks:  # siehe Lektion 12
                raise RuntimeError("Ausstehende Sicherheitsprüfungen: menschliche Intervention erforderlich")
            for action in call.actions:
                print(f"  Aktion: {action.type}")
            execute_actions(page, call.actions)
            screenshot = base64.b64encode(page.screenshot()).decode("utf-8")

            response = client.responses.create(
                model=MODEL,
                tools=[{"type": "computer"}],
                previous_response_id=response.id,
                input=[{
                    "type": "computer_call_output",
                    "call_id": call.call_id,
                    "output": {
                        "type": "computer_screenshot",
                        "image_url": f"data:image/png;base64,{screenshot}",
                        "detail": "original",
                    },
                }],
            )
        raise RuntimeError("Maximale Anzahl an Runden erreicht: prüfen Sie den Seitenzustand")
    finally:
        browser.close()
        pw.stop()

Drei Sicherheitsvorkehrungen sind bereits vorhanden. MAX_TURNS begrenzt den Zyklus: Ohne diese Begrenzung würde ein desorientierter Agent Ihr Budget bis zur Erschöpfung verbrauchen. Ein Aufruf mit ausstehenden Sicherheitsprüfungen (pending_safety_checks) stoppt alles, wie im offiziellen OpenAI-Beispiel: Lektion 12 zeigt, wie sie durch einen Menschen validiert werden können. Und eine normale Abschlussmeldung wird durch das Fehlen eines computer_call signalisiert: Das Modell hat aufgehört zu handeln und antwortet Ihnen, und Sie holen den Seitentitel aus output_text ab.

Workflow starten

if __name__ == "__main__":
    launch_agent(
        "Suchen Sie 'Computer Use' in der Suchmaschine von Wikipedia, "
        "öffnen Sie das erste Ergebnis und geben Sie mir den Titel der Seite. "
        "Verwenden Sie das computer-Tool, um auf die Oberfläche zu wirken."
    )

Mit headless=False ist die Vorstellung lehrreich: Das Fenster öffnet sich, der Klick landet im Suchfeld, der Text erscheint, der erste Link öffnet sich, und der Titel kommt in Ihrer Konsole zurück. Beobachten Sie es zwei oder drei Mal, bevor Sie zu anspruchsvolleren Aufgaben übergehen; Sie werden genau sehen, wo der Agent zögert und worauf Ihre Anweisungen eingehen sollten.

Eine wiederverwendbare Funktion für den Rest des Kurses

Die folgenden Lektionen arbeiten auf einer bereits geöffneten Seite – nach einer Anmeldung, mitten in einem Workflow. Sie stützen sich auf run_agent(task, page=page): denselben Zyklus, extrahiert aus launch_agent, mit optionalen instructions, die in jeder Runde zurückgegeben werden (Lektion 5 erklärt warum).

def run_agent(task: str, page, instructions: str | None = None, max_turns: int = MAX_TURNS) -> str:
    """Computer Use Zyklus auf einer bereits geöffneten Seite; gibt die endgültige Nachricht zurück."""
    request = {"model": MODEL, "tools": [{"type": "computer"}]}
    if instructions:
        request["instructions"] = instructions  # in jedem Aufruf zurückzugeben

    response = client.responses.create(**request, input=task)
    for turn in range(max_turns):
        call = next((i for i in response.output if i.type == "computer_call"), None)
        if call is None:
            return response.output_text
        if call.pending_safety_checks:
            raise RuntimeError("Ausstehende Sicherheitsprüfungen: menschliche Intervention erforderlich")

        execute_actions(page, call.actions)
        screenshot = base64.b64encode(page.screenshot()).decode("utf-8")
        response = client.responses.create(
            **request,
            previous_response_id=response.id,
            input=[{
                "type": "computer_call_output",
                "call_id": call.call_id,
                "output": {
                    "type": "computer_screenshot",
                    "image_url": f"data:image/png;base64,{screenshot}",
                    "detail": "original",
                },
            }],
        )
    raise RuntimeError("Maximale Anzahl an Runden erreicht: prüfen Sie den Seitenzustand")

Drei Fehler, die Sie begegnen werden

Klickt der Agent systematisch neben sein Ziel? Der Übeltäter ist fast immer ein Skalierungsunterschied zwischen dem gesendeten Screenshot und der Seite, auf der Sie klicken: verkleinerter Screenshot, Browser-Vergrößerung, High-Density-Bildschirm. Die Koordinaten des Modells beziehen sich auf das Bild, das es erhalten hat; wenn Sie es verkleinern, konvertieren Sie seine Koordinaten in die entgegengesetzte Richtung.

Geht der Agent in Kreisen und wiederholt dieselbe Geste? Die Rundenbegrenzung wird ihn schließlich stoppen, aber es ist besser, den Zyklus früher zu erkennen: Wenn derselbe Screenshot mehrere Male hintereinander zurückkommt, macht der Agent keinen Fortschritt, und das Unterbrechen spart Ihnen unnötige Aufrufe.

Handelt der Agent auf einer Seite, die noch leer ist? Auf einer schweren Seite gibt page.goto() zurück, bevor das Rendieren abgeschlossen ist, und der erste Screenshot zeigt nur einen weißen Hintergrund. Warten Sie auf Netzwerkinaktivität, bevor Sie das Bild machen:

page.goto(url)
page.wait_for_load_state("networkidle")

Kernaussagen

  • Ein Computer Use Agent kombiniert einen Aktionshandler, einen Kontrollzyklus und eine Antwortverkettung
  • Der erste Aufruf sendet die Aufgabe; jeder Screenshot kommt in einem computer_call_output mit derselben call_id zurück
  • Der Handler führt Aktionen nacheinander aus und lehnt ab, was er nicht ausführen kann
  • Begrenzen Sie immer die Anzahl der Runden, stoppen Sie bei pending_safety_checks und verwenden Sie headless=False während der Entwicklung
  • run_agent(task, page=page) nutzt diesen Zyklus für eine bereits geöffnete Seite; dies ist, was die folgenden Lektionen verwenden