Architectuur: Schermafbeeldingen, Acties en de Interactielus
Op deze pagina
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, toolcomputer_20241022). Deze maakt nu gebruik van decomputer-tool van de Responses API van OpenAI, waarbij acties gegroepeerd zijn in eencomputer_callen schermafbeeldingen worden geretourneerd viacomputer_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.
| Actie | Beschrijving | Velden |
|---|---|---|
click | Klikken op een positie | x, y, button (left, right, wheel, back, forward) |
double_click | Dubbelklikken | x, y |
drag | Slepen langs een pad | path (lijst van punten) |
move | De aanwijzer verplaatsen | x, y |
scroll | Scrollen | x, y, scroll_x, scroll_y |
keypress | Toets of combinatie | keys (bijv. ["CTRL", "A"]) |
type | Tekst typen | text |
wait | De pagina laten laden | — |
screenshot | Een 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_callbevat 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_outputmet dezelfdecall_id, gekoppeld viaprevious_response_id - Elke beurt kost tokens en een afbeelding: beperk het aantal beurten en meet voordat u begroot