Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Arkitektur: Skärmdumpar, åtgärder och interaktionsloopen

Lektion 2 av 14 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Perceptions- och handlingsloopen
  2. Startpunkten: skärmdumpen
  3. Analys och beslut
  4. Åtgärdsrepertoaren
  5. Det fullständiga flödet
  6. Vad ett loopvarv kostar
  7. Viktiga punkter

Lektionen omskriven den 3 november 2026 baserat på OpenAIs guide Computer use och Computer use integration recipes: Denna kurs förlitade sig tidigare på Anthropic API (import anthropic, verktyg computer_20241022). Den använder nu OpenAIs Responses API-verktyg computer, där åtgärder grupperas i ett computer_call och skärmdumpar returneras via computer_call_output. Vi har tagit bort ospecificerade token-antal och tidsuppskattningar från den tidigare versionen. Källor: Computer use · Integration recipes.

Perceptions- och handlingsloopen

Hela arkitekturen för Computer Use kokar ner till en enda cykel: observera → besluta → agera → observera. Så länge denna cykel inte är klar i ditt huvud kommer dina automatiseringar att vara ostadiga; när den väl sitter är resten bara rördragning.

Skillnaden mot ett Selenium-skript ligger i var kunskapen finns. Selenium kör blindt en förbestämd sekvens: klicka här, sedan där, skriv sedan detta. Computer Use väljer nästa steg först efter att ha sett resultatet av det föregående. En popup dyker upp, en sida laddar långsammare eller en knappetikett ändras över natten: i alla tre fallen ser modellen den faktiska situationen och anpassar sig, medan skriptet fortsätter recitera ut i tomma intet.

Med OpenAIs verktyg computer sker utbytet i tre steg: du skickar uppgiften, du utför de åtgärder modellen returnerar, och sedan skickar du tillbaka en skärmdump. Din applikation håller i mus och tangentbord; modellen fattar bara besluten.

Startpunkten: skärmdumpen

Varje varv förlitar sig på en bild av skärmens aktuella tillstånd. Denna skärmdump kommer från en webbläsare som styrs av Playwright – det vanligaste fallet för webbautomatisering – ett virtuellt skrivbord vid automatisering av skrivbordsprogram, eller en Docker-container som isolerar agenten. OpenAI rekommenderar att du använder en isolerad webbläsare eller virtuell maskin i alla fall.

import base64

def capture_screen(page) -> str:
    """Ta en skärmdump med Playwright och returnera PNG-bilden som base64."""
    return base64.b64encode(page.screenshot()).decode("utf-8")

Skärmdumpen skickas tillbaka till modellen som en PNG-data-URL. Den räknas som en bildinmatning, vilket påverkar kostnaden för varje varv: fönsterstorleken du fångar är en verklig designparameter.

Analys och beslut

Modellen tar emot uppgiften, konversationshistoriken och den senaste skärmdumpen. Svaret är inte en mening utan ett computer_call-objekt, som bär på en ordnad lista med åtgärder att utföra. Här är ett exempel från OpenAIs dokumentation som väljer ett sökfält och skriver sedan ett ord:

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

Två detaljer är viktiga. Det första anropet kan innehålla endast en screenshot-åtgärd: modellen ber då att få se skärmen innan den agerar, och du returnerar en skärmdump utan att ändra något. Dessutom betyder status: "completed" att modellen har avslutat genereringen av anropet, inte att åtgärderna har utförts: det är upp till dig att exekvera dem.

Åtgärdsrepertoaren

Ordförrådet som står till modellens förfogande är avsiktligt begränsat; kombinerade täcker dessa primitiver det mesta en människa gör med mus och tangentbord.

ÅtgärdBeskrivningFält
clickKlicka på en positionx, y, button (left, right, wheel, back, forward)
double_clickDubbelklickax, y
dragDra längs en banapath (lista med punkter)
moveFlytta pekarenx, y
scrollSkrollax, y, scroll_x, scroll_y
keypressTangent eller kombinationkeys (t.ex. ["CTRL", "A"])
typeSkriv texttext
waitLåt sidan ladda—
screenshotBegär en ny skärmdump—

Det fullständiga flödet

Sammansatta skapar dessa element följande loop, modellerad efter OpenAIs dokumentation. Så länge svaret innehåller ett computer_call utför du dess åtgärder, fångar skärmen och returnerar skärmdumpen i ett computer_call_output som återanvänder samma call_id; previous_response_id länkar varje varv till det föregående.

from openai import OpenAI

client = OpenAI()

def computer_use_loop(page, task: str):
    """Computer Use-loop med computer-verktyget från 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  # inga fler åtgärder begärda: uppgiften är klar

        execute_actions(page, call.actions)  # din åtgärdshanterare (Lektion 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",
                },
            }],
        )

Denna loop har inga skyddsräcken än: i produktion bör du begränsa antalet varv, duration och kostnad; stoppa om ett anrop innehåller väntande säkerhetskontroller (pending_safety_checks); och verifiera det faktiska resultatet snarare än att bara lita på modellens slutmeddelande. Dessa är OpenAIs säkerhetsriktlinjer, som behandlas i lektion 12.

Vad ett loopvarv kostar

Varje begäran till Responses API debiterar för in- och utdatatokens, och varje skärmdump räknas som en bildinmatning; en värdmiljö kan debiteras separat. Kostnaden för en uppgift beror därför på antalet varv, skärmdumpens storlek och modellen – och den växer snabbare än antalet varv, eftersom även med previous_response_id debiteras alla inmatningstokens från tidigare svar i kedjan som indata vid varje begäran. OpenAI tillhandahåller en kalkylator för bildkostnader och exponerar användning för varje begäran: mät på dina egna arbetsflöden innan du budgeterar. Ett Selenium-skript kommer alltid att göra samma sak snabbare och billigare – men du måste skriva om det nästa gång formuläret ändras, vilket agenten inte kräver.

Viktiga punkter

  • Loopen uppgift → åtgärder → skärmdump är hjärtat i Computer Use; din applikation utför åtgärderna
  • Med OpenAI deklarerar du verktyget med tools=[{"type": "computer"}] i Responses API
  • Ett computer_call bär på en ordnad lista med åtgärder (click, type, scroll, keypress etc.) att utföra i sekvens
  • Skärmdumpen returneras till modellen i ett computer_call_output med samma call_id, kedjat via previous_response_id
  • Varje varv kostar tokens och en bild: begränsa antalet varv och mät innan du budgeterar