Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Eerste workflow: navigeren en interactie

Les 4 van 14 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. De onderdelen samenvoegen
  2. De actiehandler
  3. De volledige lus
  4. De workflow starten
  5. Een herbruikbare functie voor de rest van de cursus
  6. Drie fouten die u zult tegenkomen
  7. Belangrijkste punten

Les herschreven op 3 november 2026 op basis van de gids Computer use van OpenAI en de Computer use integration recipes: de agent gebruikt het computer-gereedschap van de Responses API, een actiehandler gemodelleerd naar de documentatie (gegropeerde acties, keypress, scroll_x/scroll_y, drag-paden), en ketening via previous_response_id, ter vervanging van code geschreven voor de API van Anthropic. Bronnen: Computer use · Integration recipes.

De onderdelen samenvoegen

U heeft de lus voor ogen en de omgeving geconfigureerd. Nu moet u ze samenvoegen tot een werkend programma: een agent die een online encyclopedie opent, zoekt naar een term, het eerste resultaat opent en rapporteert welke titel de bereikte pagina heeft. Het scenario lijkt bescheiden, maar het omvat de fundamentele gebaren—navigeren, typen, klikken, informatie lezen—en alles wat u hierna bouwt, is slechts een langere variant hiervan.

De actiehandler

Het model neemt beslissingen, maar voert niets zelf uit: het retourneert een lijst met acties, en uw code vertaalt deze op volgorde naar Playwright-gebaren. Deze functie volgt de handler die door OpenAI is gepubliceerd in zijn integratierecepten, vereenvoudigd voor een 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):
    """Executes the actions from a computer_call in order."""
    for action in actions:
        if action.type in ("click", "double_click", "drag", "move", "scroll") and getattr(action, "keys", None):
            raise ValueError("Mouse action with modifier key: not handled here")
        match action.type:
            case "click":
                button = getattr(action, "button", "left")
                if button not in BUTTONS:  # back and forward don't exist in Playwright
                    raise ValueError(f"Unsupported button: {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 is taken after each batch of actions
            case _:
                raise ValueError(f"Unsupported action: {action.type}")

Twee keuzes verdienen uitleg. De namen van toetsen en knoppen die door het model worden geretourneerd (ENTER, CTRL, wheel…) komen niet overeen met wat Playwright verwacht (Enter, Control, middle…): de mapping-tabellen, overgenomen uit de documentatie, overbruggen deze kloof, en de knoppen back en forward, die de API ook kan aanvragen, worden geweigerd zoals in de handler van OpenAI. En een onbekende actie leidt tot een fout in plaats van stilzwijgend te worden genegeerd: een harde stop is beter dan een agent die denkt gehandeld te hebben terwijl dat niet zo is.

De volledige lus

De agent orkestreert vervolgens de cyclus. De eerste oproep verzendt de taak; als deze alleen een verzoek om een screenshot bevat, retourneert u eenvoudig het scherm. Elke screenshot komt terug bij het model als resultaat van de oproep die erom vroeg, gerefereerd via zijn call_id, en previous_response_id koppelt de beurten aan elkaar.

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"):
    """Launches a Computer Use agent on a given task."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=False)  # False to observe
    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"Task complete: {response.output_text}")
                return response.output_text

            if call.pending_safety_checks:  # see lesson 12
                raise RuntimeError("Pending safety checks: human intervention required")
            for action in call.actions:
                print(f"  Action: {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("Maximum number of turns reached: check the page state")
    finally:
        browser.close()
        pw.stop()

Drie veiligheidsmaatregelen zijn al ingesteld. MAX_TURNS begrenst de lus: zonder deze limiet zou een gedesoriënteerde agent uw budget tot uitputting verbruiken. Een oproep met openstaande veiligheidscontroles (pending_safety_checks) stopt alles, zoals in het officiële voorbeeld van OpenAI: les 12 laat zien hoe u deze door een mens laat valideren. En normale voltooiing wordt aangegeven door de afwezigheid van een computer_call: het model is gestopt met handelen en antwoordt u, waarna u de paginatitel ophaalt uit output_text.

De workflow starten

if __name__ == "__main__":
    launch_agent(
        "Search for 'Computer Use' in Wikipedia's search engine, "
        "open the first result, and give me the title of the page. "
        "Use the computer tool to act on the interface."
    )

Met headless=False is de show instructief: het venster opent, de klik landt in het zoekveld, de tekst verschijnt, de eerste link opent en de titel komt terug in uw console. Laat het twee of drie keer draaien voordat u doorgaat naar ambitieuzere taken; u ziet precies waar de agent aarzelt en wat uw instructies moeten adresseren.

Een herbruikbare functie voor de rest van de cursus

De volgende lessen werken op een reeds geopende pagina—na een inlogprocedure, midden in een workflow. Ze vertrouwen op run_agent(task, page=page): dezelfde lus, geëxtraheerd uit launch_agent, met optionele instructions die bij elke beurt worden geretourneerd (les 5 legt uit waarom).

def run_agent(task: str, page, instructions: str | None = None, max_turns: int = MAX_TURNS) -> str:
    """Computer Use loop on an already-open page; returns the final message."""
    request = {"model": MODEL, "tools": [{"type": "computer"}]}
    if instructions:
        request["instructions"] = instructions  # to be returned on each request

    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("Pending safety checks: human intervention required")

        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("Maximum number of turns reached: check the page state")

Drie fouten die u zult tegenkomen

Klikt de agent systematisch naast zijn doelwit? De boosdoener is bijna altijd een schaalverschil tussen de verzonden screenshot en de pagina waarop u klikt: formaatgewijzigde screenshot, browserzoom, scherm met hoge dichtheid. De coördinaten van het model verwijzen naar de afbeelding die het heeft ontvangen; als u deze verkleint, converteert u de coördinaten in de tegenovergestelde richting.

Gaat de agent in cirkels en herhaalt hij hetzelfde gebaar? De turn-limiet zal hem uiteindelijk stoppen, maar het is beter de lus eerder te detecteren: als dezelfde screenshot meerdere keren achter elkaar terugkomt, boekt de agent geen vooruitgang, en het onderbreken ervan bespaart u onnodige oproepen.

Handelt de agent op een pagina die nog leeg is? Op een zware site keert page.goto() terug voordat het renderen is voltooid, en toont de eerste screenshot alleen een witte achtergrond. Wacht op netwerkinactiviteit voordat u de foto maakt:

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

Belangrijkste punten

  • Een Computer Use-agent combineert een actiehandler, een controlemodule en respons-ketening
  • De eerste oproep verzendt de taak; elke screenshot komt terug in een computer_call_output met dezelfde call_id
  • De handler voert acties op volgorde uit en weigert wat hij niet weet uit te voeren
  • Beperk altijd het aantal beurten, stop bij pending_safety_checks en gebruik headless=False tijdens ontwikkeling
  • run_agent(task, page=page) hergebruikt deze lus voor een reeds geopende pagina; dit is wat de volgende lessen gebruiken