Arkitektur: Skærmbilleder, handlinger og interaktionsløkken
På denne side
Lektionen er omskrevet den 3. november 2026 baseret på OpenAIs guide til Computer use og opskrifter til integration af computerbrug: Dette kursus relied tidligere på Anthropic’s API (
import anthropic, værktøjcomputer_20241022). Det bruger nu OpenAIs Responses API-værktøjcomputer, hvor handlinger grupperes i etcomputer_call, og skærmbilleder returneres viacomputer_call_output. Vi har fjernet de ikke-underbyggede optællinger af tokens og varighedsestimater fra den tidligere version. Kilder: Computer use · Integration recipes.
Perceptions-handlings-løkken
Hele arkitekturen bag Computer Use kan koges ned til én enkelt cyklus: observer → beslut → handl → observer. Indtil denne cyklus står helt klar i dit hoved, vil dine automatiseringer forblive ustabile; når først det klikker, er resten blot rørarbejde.
Forskellen fra et Selenium-script ligger i, hvor videnen befinder sig. Selenium udfører blindt en på forhånd bestemt sekvens: klik her, så der, og skriv derefter dette. Computer Use vælger først næste skridt, efter at have set resultatet af det foregående. Hvis en pop-up dukker op, en side tager længere tid om at loade, eller en knaptekst ændres over natten: i alle tre tilfælde ser modellen den faktiske situation og justerer sig, mens scriptet fortsætter med at recitere ud i det tomme rum.
Med OpenAIs computer-værktøj foregår udvekslingen i tre trin: du sender opgaven, du udfører de handlinger, modellen returnerer, og derefter sender du et skærmbillede tilbage. Din applikation styrer mus og tastatur; modellen træffer kun beslutningerne.
Startpunktet: Skærmbilledet
Hvert eneste skridt i løkken afhænger af et billede af skærmens aktuelle tilstand. Dette skærmbillede kommer fra en browser styret af Playwright – det mest almindelige tilfælde ved webautomatisering – et virtuelt skrivebord ved automatisering af en desktop-applikation eller en Docker-container, der isolerer agenten. OpenAI anbefaler at bruge en isoleret browser eller virtuel maskine i alle tilfælde.
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")
Skærmbilledet sendes tilbage til modellen som en PNG-data-URL. Det tæller som et billedinput, så det påvirker omkostningerne ved hvert skridt: den vinduesstørrelse, du fanger, er en reel designparameter.
Analyse og beslutning
Modellen modtager opgaven, samtalehistorikken og det seneste skærmbillede. Dens svar er ikke en sætning, men et computer_call-element, som indeholder en ordnet liste over handlinger, der skal udføres. Her er et eksempel fra OpenAIs dokumentation, der vælger et søgefelt og derefter skriver et ord:
{
"type": "computer_call",
"call_id": "call_002",
"actions": [
{ "type": "click", "button": "left", "x": 405, "y": 157 },
{ "type": "type", "text": "penguin" }
],
"status": "completed"
}
To detaljer er vigtige. Det første kald kan kun indeholde en screenshot-handling: modellen beder om at se skærmen, før den handler, og du returnerer et skærmbillede uden at ændre noget. Desuden betyder status: "completed", at modellen er færdig med at generere kaldet, ikke at handlingerne er udført: det er op til dig at eksekvere dem.
Handlingsrepertoiret
Det ordforråd, der står til modellens rådighed, er bevidst begrænset; kombineret dækker disse primitiver det meste af, hvad et menneske gør med mus og tastatur.
| Handling | Beskrivelse | Felter |
|---|---|---|
click | Klik på en position | x, y, button (left, right, wheel, back, forward) |
double_click | Dobbeltklik | x, y |
drag | Træk langs en sti | path (liste over punkter) |
move | Flyt markøren | x, y |
scroll | Rul | x, y, scroll_x, scroll_y |
keypress | Tast eller kombination | keys (f.eks. ["CTRL", "A"]) |
type | Skriv tekst | text |
wait | Lad siden loade | — |
screenshot | Anmod om nyt skærmbillede | — |
Den fulde flow
Sammenkoblet skaber disse elementer følgende løkke, modelleret efter OpenAIs dokumentation. Så længe svaret indeholder et computer_call, udfører du dets handlinger, fanger skærmen og returnerer skærmbilledet i et computer_call_output, der genbruger samme call_id; previous_response_id linker hvert skridt til det foregående.
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",
},
}],
)
Denne løkke har endnu ingen sikkerhedsforanstaltninger: i produktion skal du begrænse antallet af skridt, varigheden og omkostningerne; stop hvis et kald indeholder afventende sikkerhedstjek (pending_safety_checks); og verificér det faktiske resultat i stedet for blot at stole på modellens endelige besked. Dette er OpenAIs retningslinjer for sikkerhed, som dækkes i lektion 12.
Hvad et løkketrin koster
Hver anmodning til Responses API opkræver betaling for input- og output-tokens, og hvert skærmbillede tæller som et billedinput; et hostet miljø kan faktureres separat. Omkostningerne ved en opgave afhænger derfor af antallet af skridt, skærmbilledets størrelse og modellen – og de vokser hurtigere end antallet af skridt, fordi selv med previous_response_id genopkræves alle input-tokens fra tidligere svar i kæden som input ved hver anmodning. OpenAI stiller en beregner for billedomkostninger til rådighed og eksponerer forbruget for hver anmodning: mål på dine egne workflows, før du lægger budget. Et Selenium-script vil altid gøre det samme hurtigere og billigere – men du bliver nødt til at omskrive det næste gang formularen ændres, hvilket agenten ikke kræver.
Vigtige pointer
- Løkken opgave → handlinger → skærmbillede er hjertet i Computer Use; din applikation udfører handlingerne
- Med OpenAI skal du deklarere værktøjet med
tools=[{"type": "computer"}]i Responses API - Et
computer_callindeholder en ordnet liste over handlinger (click,type,scroll,keypressosv.), der skal udføres i rækkefølge - Skærmbilledet returneres til modellen i et
computer_call_outputmed sammecall_id, kædet sammen afprevious_response_id - Hvert skridt koster tokens og et billede: begræns antallet af skridt og mål før budgettering