Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Architectuur: Schermafbeeldingen, Acties en de Interactielus

Les 2 van 14 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. De perceptie-actielus
  2. Het startpunt: de schermafbeelding
  3. Analyse en besluitvorming
  4. Het actie-repertoire
  5. De volledige stroom
  6. Wat een lusbeurt kost
  7. Belangrijkste punten

Les herschreven op 3 november 2026 op basis van de gids Computer use en de Computer use integration recipes van OpenAI: Deze cursus leunde eerder op de API van Anthropic (import anthropic, tool computer_20241022). Deze maakt nu gebruik van de computer-tool van de Responses API van OpenAI, waarbij acties gegroepeerd zijn in een computer_call en schermafbeeldingen worden geretourneerd via computer_call_output. We hebben de niet-onderbouwde aantallen tokens en duurramingen uit de vorige versie verwijderd. Bronnen: Computer use · Integration recipes.

De perceptie-actielus

De volledige architectuur van Computer Use komt neer op één enkele cyclus: observeren → beslissen → handelen → observeren. Zolang deze cyclus niet helder voor u is, blijven uw automatiseringen onvoorspelbaar; zodra het klikt, is de rest slechts technische infrastructuur.

Het verschil met een Selenium-script zit hem in de locatie van de kennis. Selenium voert blindelings een vooraf bepaalde reeks uit: klik hier, dan daar, typ vervolgens dit. Computer Use kiest de volgende stap pas nadat het resultaat van de vorige stap is waargenomen. Er verschijnt een pop-up, een pagina laadt trager dan verwacht, of een knoplabel verandert overnight: in alle drie de gevallen ziet het model de feitelijke situatie en past het zich aan, terwijl het script doorgaat met het opzeggen van instructies in het niets.

Met de computer-tool van OpenAI verloopt de uitwisseling in drie stappen: u verzendt de taak, u voert de acties uit die het model retourneert, en vervolgens stuurt u een schermafbeelding terug. Uw applicatie bedient de muis en het toetsenbord; het model neemt uitsluitend de beslissingen.

Het startpunt: de schermafbeelding

Elke beurt is afhankelijk van een afbeelding van de huidige schermstatus. Deze schermafbeelding komt van een browser die wordt aangestuurd door Playwright—de meest voorkomende casus voor webautomatisering—een virtueel bureaublad bij het automatiseren van een desktopapplicatie, of een Docker-container die de agent isoleert. OpenAI raadt aan om in alle gevallen een geïsoleerde browser of virtuele machine te gebruiken.

import base64

def capture_screen(page) -> str:
    """Capture the screen with Playwright and return the PNG image as base64."""
    return base64.b64encode(page.screenshot()).decode("utf-8")

De schermafbeelding gaat als een PNG data URL terug naar het model. Dit telt als een beeldinvoer, dus het beïnvloedt de kosten van elke beurt: de venstergrootte die u vastlegt, is een echt ontwerpparameter.

Analyse en besluitvorming

Het model ontvangt de taak, de conversatiegeschiedenis en de meest recente schermafbeelding. Het antwoord is geen zin, maar een computer_call-item, dat een geordende lijst bevat van uit te voeren acties. Hier is een voorbeeld uit de documentatie van OpenAI dat een zoekveld selecteert en vervolgens een woord typt:

{
  "type": "computer_call",
  "call_id": "call_002",
  "actions": [
    { "type": "click", "button": "left", "x": 405, "y": 157 },
    { "type": "type", "text": "penguin" }
  ],
  "status": "completed"
}

Twee details zijn belangrijk. De eerste oproep kan slechts één screenshot-actie bevatten: het model vraagt dan om het scherm te zien voordat het handelt, en u retourneert een schermafbeelding zonder iets te wijzigen. Bovendien betekent status: "completed" dat het model klaar is met het genereren van de oproep, niet dat de acties zijn uitgevoerd: het uitvoeren ervan is aan u.

Het actie-repertoire

De woordenschat die voor het model beschikbaar is, is bewust beperkt; gecombineerd dekken deze primitieven het meeste af wat een mens met een muis en toetsenbord doet.

ActieBeschrijvingVelden
clickKlikken op een positiex, y, button (left, right, wheel, back, forward)
double_clickDubbelklikkenx, y
dragSlepen langs een padpath (lijst van punten)
moveDe aanwijzer verplaatsenx, y
scrollScrollenx, y, scroll_x, scroll_y
keypressToets of combinatiekeys (bijv. ["CTRL", "A"])
typeTekst typentext
waitDe pagina laten laden—
screenshotEen nieuwe schermafbeelding aanvragen—

De volledige stroom

Samengevoegd creëren deze elementen de volgende lus, gemodelleerd naar de documentatie van OpenAI. Zolang het antwoord een computer_call bevat, voert u de acties uit, legt u het scherm vast en retourneert u de schermafbeelding in een computer_call_output dat dezelfde call_id hergebruikt; previous_response_id koppelt elke beurt aan de vorige.

from openai import OpenAI

client = OpenAI()

def computer_use_loop(page, task: str):
    """Computer Use loop with the computer tool from the Responses API."""
    response = client.responses.create(
        model="gpt-6.1-sol",
        tools=[{"type": "computer"}],
        input=task,
    )

    while True:
        call = next(
            (item for item in response.output if item.type == "computer_call"),
            None,
        )
        if call is None:
            return response.output_text  # no more actions requested: task is done

        execute_actions(page, call.actions)  # your action handler (Lesson 4)
        screenshot = capture_screen(page)

        response = client.responses.create(
            model="gpt-6.1-sol",
            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",
                },
            }],
        )

Deze lus heeft nog geen beveiligingsmechanismen: beperk in productie het aantal beurten, de duur en de kosten; stop als een oproep pending safety checks (pending_safety_checks) bevat; en verifieer het feitelijke resultaat in plaats van alleen te vertrouwen op het laatste bericht van het model. Dit zijn de veiligheidsrichtlijnen van OpenAI, behandeld in Les 12.

Wat een lusbeurt kost

Elk verzoek aan de Responses API brengt kosten in rekening voor input- en outputtokens, en elke schermafbeelding telt als een beeldinvoer; een gehoste omgeving kan apart worden gefactureerd. De kosten van een taak hangen daarom af van het aantal beurten, de grootte van de schermafbeelding en het model—en ze stijgen sneller dan het aantal beurten, omdat zelfs met previous_response_id alle inputtokens van eerdere antwoorden in de keten bij elk verzoek opnieuw als input worden gefactureerd. OpenAI biedt een rekenhulpmiddel voor beeldkosten en exposeert het gebruik voor elk verzoek: meet dit op uw eigen workflows voordat u begroot. Een Selenium-script zal altijd hetzelfde doen, sneller en goedkoper—maar u zult het opnieuw moeten schrijven zodra het formulier verandert, wat bij de agent niet nodig is.

Belangrijkste punten

  • De lus taak → acties → schermafbeelding is het hart van Computer Use; uw applicatie voert de acties uit
  • Declareer bij OpenAI de tool met tools=[{"type": "computer"}] in de Responses API
  • Een computer_call bevat een geordende lijst van acties (click, type, scroll, keypress, enz.) die sequentieel moeten worden uitgevoerd
  • De schermafbeelding keert terug naar het model in een computer_call_output met dezelfde call_id, gekoppeld via previous_response_id
  • Elke beurt kost tokens en een afbeelding: beperk het aantal beurten en meet voordat u begroot