Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Arkitektur: Skærmbilleder, handlinger og interaktionsløkken

Lektion 2 af 14 Opdateret 3. november 2026 Udvikler
På denne side
  1. Perceptions-handlings-løkken
  2. Startpunktet: Skærmbilledet
  3. Analyse og beslutning
  4. Handlingsrepertoiret
  5. Den fulde flow
  6. Hvad et løkketrin koster
  7. Vigtige pointer

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øj computer_20241022). Det bruger nu OpenAIs Responses API-værktøj computer, hvor handlinger grupperes i et computer_call, og skærmbilleder returneres via computer_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.

HandlingBeskrivelseFelter
clickKlik på en positionx, y, button (left, right, wheel, back, forward)
double_clickDobbeltklikx, y
dragTræk langs en stipath (liste over punkter)
moveFlyt markørenx, y
scrollRulx, y, scroll_x, scroll_y
keypressTast eller kombinationkeys (f.eks. ["CTRL", "A"])
typeSkriv teksttext
waitLad siden loade—
screenshotAnmod 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_call indeholder en ordnet liste over handlinger (click, type, scroll, keypress osv.), der skal udføres i rækkefølge
  • Skærmbilledet returneres til modellen i et computer_call_output med samme call_id, kædet sammen af previous_response_id
  • Hvert skridt koster tokens og et billede: begræns antallet af skridt og mål før budgettering