Viktige poeng

• Skjermbilde-handling-løkke er kjernemønsteret: Skriptet ditt tar et skjermbilde, sender det til GPT-5.4 via Responses API med computer_use aktivert, mottar strukturerte handlingskommandoer (click, type, scroll), og utfører dem med PyAutoGUI i en løkke.
• GPT-5.4 slo menneskelige eksperter på OSWorld med 75%: Dette er den første AI-modellen som overgår menneskelig ytelse på benchmarks for skrivebordsautomatisering, noe som gjør praktisk automatisering levedyktig for reelle arbeidsflyter.
• Kostnaden er overraskende lav: En typisk automatiseringsøkt med 10-20 skjermbilder koster $0.10-0.50, fakturert til GPT-5.4 sine standardpriser (~$10/$30 per million input/output tokens).
• Sikkerhet krever at din kode utfører handlinger: GPT-5.4 sender kun handlingskommandoer — din applikasjon bestemmer om de skal utføres, noe som gjør testing i sandkasse og gjennomgang av handlinger essensielt før du kjører uten tilsyn.
• Tre forutsetninger for å komme i gang: Python 3.10+, en OpenAI API key med Tier 1 tilgang (minimum $5 tidligere forbruk), og et skrivebordsmiljø med en skjerm.

GPT-5.4 skåret 75% på OSWorld benchmark, og slo menneskelige eksperter på skrivebordsautomatisering for første gang. Men å kjenne til benchmark-resultatene og faktisk bruke Computer Use selv er to veldig forskjellige ting.

Denne guiden bygger bro over det gapet. Ved slutten vil du ha et fungerende Python-skript som tar skjermbilder av skrivebordet ditt, sender dem til GPT-5.4, mottar strukturerte handlingskommandoer, og utfører dem automatisk. Ingen teori, ingen hype — bare kode du kan kjøre i dag.

---

Dette skal du bygge

Du vil bygge en komplett løkke for skrivebordsautomatisering som fungerer slik:

1. Skriptet ditt tar et skjermbilde av skjermen din
2. Det sender skjermbildet til GPT-5.4 via OpenAI Responses API med computer_use verktøyet aktivert
3. GPT-5.4 analyserer skjermbildet og returnerer strukturerte handlinger (click, type, scroll, keypress)
4. Skriptet ditt utfører disse handlingene ved hjelp av PyAutoGUI
5. Løkken gjentas til oppgaven er fullført

Ved slutten av denne veiledningen vil du ha to fungerende eksempler: ett som fyller ut et nettskjema automatisk, og ett som henter data fra en skrivebordsapplikasjon til en CSV fil.

---

Forutsetninger

Før du starter, sørg for at du har følgende:

• Python 3.10 eller nyere installert på maskinen din
• En OpenAI API key med tilgang til GPT-5.4 (krever en betalt konto med minst Tier 1 tilgang — minimum $5 tidligere forbruk)
• Et skrivebordsmiljø — Computer Use fungerer på macOS, Windows, og Linux med en skjerm. For hodeløse servere trenger du en virtuell skjerm som Xvfb
• Grunnleggende kjennskap til Python (du trenger ikke være en ekspert — all kode er oppgitt)

---

Steg 1: Sett opp miljøet ditt

Start med å opprette en prosjektmappe og installer de nødvendige pakkene.

mkdir gpt54-computer-use && cd gpt54-computer-use
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

pip install openai pyautogui pillow

Hva hver pakke gjør:

• openai — Offisiell OpenAI Python SDK for å kalle GPT-5.4 API
• pyautogui — Plattformuavhengig bibliotek for å kontrollere mus og tastatur
• pillow — Bildebehandlingsbibliotek for håndtering av skjermbilder

Deretter setter du din API key som en miljøvariabel:

export OPENAI_API_KEY="sk-your-api-key-here"

På Windows, bruk set OPENAI_API_KEY=sk-your-api-key-here i stedet.

Opprett en fil kalt automation.py og legg til det grunnleggende oppsettet:

import os
import base64
import json
import pyautogui
from openai import OpenAI

client = OpenAI()  # Reads OPENAI_API_KEY from environment

# Safety: add a short pause before actions so you can move the mouse
# to a corner to trigger PyAutoGUI's fail-safe and abort
pyautogui.PAUSE = 0.5
pyautogui.FAILSAFE = True

SCREEN_WIDTH, SCREEN_HEIGHT = pyautogui.size()
print(f"Screen resolution: {SCREEN_WIDTH}x{SCREEN_HEIGHT}")

Kjør dette for å verifisere at alt er installert riktig:

python automation.py

Du bør se skjermoppløsningen din skrevet ut. Hvis du får importfeil, dobbeltsjekk at du aktiverte det virtuelle miljøet og installerte alle pakkene.

---

Steg 2: Ta et skjermbilde

Computer Use fungerer ved å analysere skjermbilder. Koden din fanger skjermen og konverterer den til en base64-kodet streng som APIen kan akseptere.

Legg til denne funksjonen i automation.py:

def take_screenshot():
    """Capture the screen and return it as a base64-encoded PNG string."""
    screenshot = pyautogui.screenshot()
    # Save to a buffer instead of disk for speed
    import io
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8")

Test den ved å legge til en rask sjekk nederst i filen:

if __name__ == "__main__":
    img_data = take_screenshot()
    print(f"Screenshot captured: {len(img_data)} characters (base64)")

Dette bør skrive ut noe som Screenshot captured: 2847392 characters (base64). Det nøyaktige tallet avhenger av skjermoppløsningen din og hva som er på skjermen.

---

Steg 3: Send et skjermbilde til GPT-5.4

Nå kommer kjernen i Computer Use: å sende et skjermbilde til GPT-5.4 med computer_use verktøyet aktivert, og motta strukturerte handlingskommandoer i retur.

Legg til denne funksjonen:

def send_to_gpt54(screenshot_b64, task_description, previous_response_id=None):
    """
    Send a screenshot to GPT-5.4 with computer_use enabled.
    Returns the API response with action commands.
    """
    tools = [
        {
            "type": "computer_use_preview",
            "display_width": SCREEN_WIDTH,
            "display_height": SCREEN_HEIGHT,
            "environment": "mac"  # Change to "windows" or "linux" as needed
        }
    ]

    input_content = [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": task_description
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{screenshot_b64}"
                    }
                }
            ]
        }
    ]

    params = {
        "model": "gpt-5.4",
        "tools": tools,
        "input": input_content,
        "reasoning": {"effort": "medium"}
    }

    if previous_response_id:
        params["previous_response_id"] = previous_response_id

    response = client.responses.create(**params)
    return response

Viktige parametere forklart:

• computer_use_preview — Forteller GPT-5.4 at den skal analysere skjermbildet og returnere skrivebordshandlinger
• display_width / display_height — Skjermoppløsningen din, slik at GPT-5.4 returnerer koordinater som samsvarer med din faktiske skjerm
• environment — Satt til "mac", "windows", eller "linux" slik at GPT-5.4 bruker de riktige hurtigtastene og UI-konvensjonene
• reasoning.effort — Kontrollerer hvor mye resonnering GPT-5.4 gjør. Bruk "medium" for standardoppgaver, "high" for komplekse arbeidsflyter med flere steg
• previous_response_id — Lenker flere kall sammen slik at GPT-5.4 husker hva den allerede har gjort

---

Steg 4: Utfør handlinger

GPT-5.4 returnerer strukturerte handlingskommandoer i sitt svar. Du må tolke disse og utføre dem med PyAutoGUI.

Legg til handlingsutføreren:

def execute_action(action):
    """Execute a single computer_use action using PyAutoGUI."""
    action_type = action.type

    if action_type == "click":
        x, y = action.x, action.y
        button = getattr(action, "button", "left")
        print(f"  -> Click ({button}) at ({x}, {y})")
        pyautogui.click(x, y, button=button)

    elif action_type == "double_click":
        x, y = action.x, action.y
        print(f"  -> Double-click at ({x}, {y})")
        pyautogui.doubleClick(x, y)

    elif action_type == "type":
        text = action.text
        print(f"  -> Type: {text[:50]}{'...' if len(text) > 50 else ''}")
        pyautogui.write(text, interval=0.03)

    elif action_type == "keypress":
        keys = action.keys
        print(f"  -> Keypress: {keys}")
        for key in keys:
            pyautogui.press(key)

    elif action_type == "scroll":
        x, y = action.x, action.y
        scroll_x = getattr(action, "scroll_x", 0)
        scroll_y = getattr(action, "scroll_y", 0)
        print(f"  -> Scroll at ({x}, {y}): x={scroll_x}, y={scroll_y}")
        pyautogui.scroll(scroll_y, x=x, y=y)

    elif action_type == "drag":
        start_x, start_y = action.start_x, action.start_y
        end_x, end_y = action.end_x, action.end_y
        print(f"  -> Drag from ({start_x}, {start_y}) to ({end_x}, {end_y})")
        pyautogui.moveTo(start_x, start_y)
        pyautogui.drag(end_x - start_x, end_y - start_y, duration=0.5)

    elif action_type == "screenshot":
        print("  -> Model requested a new screenshot")
        return "screenshot_requested"

    else:
        print(f"  -> Unknown action type: {action_type}")

    return "executed"


def process_response(response):
    """Parse GPT-5.4's response and execute all actions."""
    needs_screenshot = False

    for item in response.output:
        if item.type == "computer_call":
            action = item.action
            result = execute_action(action)
            if result == "screenshot_requested":
                needs_screenshot = True
        elif item.type == "text":
            print(f"  GPT-5.4 says: {item.text}")

    return needs_screenshot, response.id

Dette håndterer alle handlingstypene som GPT-5.4 kan returnere: klikking, dobbeltklikking, skriving, tastetrykk, rulling og dra-og-slipp.

---

Steg 5: Bygg automatiseringsløkken

Koble nå alt sammen til en komplett automatiseringsløkke. Dette er hovedmotoren som kjører oppgavene dine:

import time

def run_automation(task_description, max_steps=25):
    """
    Run a complete automation loop:
    screenshot -> send to GPT-5.4 -> execute actions -> repeat.
    """
    print(f"Starting automation: {task_description}")
    print(f"Max steps: {max_steps}")
    print("-" * 60)

    previous_response_id = None

    for step in range(1, max_steps + 1):
        print(f"\nStep {step}/{max_steps}")

        # 1. Take a screenshot
        print("  Capturing screenshot...")
        screenshot_b64 = take_screenshot()

        # 2. Send to GPT-5.4
        print("  Sending to GPT-5.4...")
        response = send_to_gpt54(
            screenshot_b64,
            task_description if step == 1 else "Continue the task based on the current screen state.",
            previous_response_id
        )

        # 3. Check if the model thinks we're done
        has_actions = False
        for item in response.output:
            if item.type == "computer_call":
                has_actions = True
                break

        if not has_actions:
            # Check if model sent a text response (likely done or needs input)
            for item in response.output:
                if item.type == "text":
                    print(f"\n  GPT-5.4: {item.text}")
            print("\n" + "=" * 60)
            print("Automation complete (no more actions to perform).")
            return True

        # 4. Execute the actions
        print("  Executing actions...")
        needs_screenshot, previous_response_id = process_response(response)

        # 5. Brief pause to let UI update
        time.sleep(1.0)

    print("\n" + "=" * 60)
    print(f"Reached maximum steps ({max_steps}). Stopping.")
    return False

Du kan nå kjøre hvilken som helst automatiseringsoppgave med et enkelt funksjonskall:

if __name__ == "__main__":
    run_automation("Open the Calculator app and compute 1234 * 5678")

Dette vil fange skjermen din, sende den til GPT-5.4, og GPT-5.4 vil finne ut hvordan man åpner Kalkulator og utfører multiplikasjonen — klikke på knapper, lese resultatet, og stoppe når den er ferdig.

---

Praktisk eksempel 1: Automatisk utfylling av et nettskjema

Her er et komplett, fungerende eksempel som fyller ut et kontaktskjema på nett. Lagre dette som autofill_form.py:

import os
import base64
import io
import time
import pyautogui
from openai import OpenAI

client = OpenAI()
pyautogui.PAUSE = 0.5
pyautogui.FAILSAFE = True
SCREEN_WIDTH, SCREEN_HEIGHT = pyautogui.size()


def take_screenshot():
    screenshot = pyautogui.screenshot()
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8")


def autofill_contact_form():
    """
    Auto-fill a contact form with sample data.
    Open the web page with the form before running this script.
    """
    form_data = {
        "First Name": "Jane",
        "Last Name": "Doe",
        "Email": "jane.doe@example.com",
        "Phone": "555-0123",
        "Company": "Acme Corp",
        "Message": "I am interested in learning more about your enterprise plan."
    }

    task = f"""Fill out the contact form visible on the screen with this data:
{chr(10).join(f'- {k}: {v}' for k, v in form_data.items())}

Click each field, clear any existing text, type the value, then move to the next field.
After filling all fields, click the Submit button.
Do NOT press Enter to submit — click the Submit button instead."""

    print("Starting form auto-fill...")
    print(f"Data to fill: {json.dumps(form_data, indent=2)}")

    previous_response_id = None

    for step in range(1, 20):
        print(f"\nStep {step}")
        screenshot_b64 = take_screenshot()

        tools = [{
            "type": "computer_use_preview",
            "display_width": SCREEN_WIDTH,
            "display_height": SCREEN_HEIGHT,
            "environment": "mac"
        }]

        input_content = [{
            "role": "user",
            "content": [
                {"type": "text", "text": task if step == 1 else "Continue filling the form."},
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}}
            ]
        }]

        params = {
            "model": "gpt-5.4",
            "tools": tools,
            "input": input_content,
            "reasoning": {"effort": "medium"}
        }
        if previous_response_id:
            params["previous_response_id"] = previous_response_id

        response = client.responses.create(**params)

        has_actions = False
        for item in response.output:
            if item.type == "computer_call":
                has_actions = True
                action = item.action
                if action.type == "click":
                    pyautogui.click(action.x, action.y)
                elif action.type == "type":
                    pyautogui.write(action.text, interval=0.03)
                elif action.type == "keypress":
                    for key in action.keys:
                        pyautogui.press(key)
                elif action.type == "scroll":
                    pyautogui.scroll(action.scroll_y, x=action.x, y=action.y)

        if not has_actions:
            for item in response.output:
                if item.type == "text":
                    print(f"GPT-5.4: {item.text}")
            print("Form filling complete.")
            return

        previous_response_id = response.id
        time.sleep(0.8)


if __name__ == "__main__":
    import json
    print("Make sure the web form is visible on your screen.")
    print("Starting in 3 seconds...")
    time.sleep(3)
    autofill_contact_form()

Hvordan bruke det:

1. Åpne en nettside med et kontaktskjema i nettleseren din
2. Sørg for at skjemaet er fullt synlig på skjermen (ingen rulling nødvendig for de første feltene)
3. Kjør python autofill_form.py
4. Se på mens GPT-5.4 identifiserer hvert felt, klikker på det, og skriver inn riktig verdi

---

Praktisk eksempel 2: Hent data fra en skrivebordsapplikasjon

Dette eksempelet leser data fra et synlig regneark eller en tabellapplikasjon og lagrer det i en CSV fil. Lagre dette som extract_data.py:

import os
import base64
import io
import csv
import time
import pyautogui
from openai import OpenAI

client = OpenAI()
pyautogui.PAUSE = 0.3
pyautogui.FAILSAFE = True
SCREEN_WIDTH, SCREEN_HEIGHT = pyautogui.size()


def take_screenshot():
    screenshot = pyautogui.screenshot()
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8")


def extract_table_data(output_file="extracted_data.csv"):
    """
    Look at the current screen, identify any table or spreadsheet,
    and extract its contents to a CSV file.
    """
    screenshot_b64 = take_screenshot()

    response = client.responses.create(
        model="gpt-5.4",
        input=[{
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": """Look at this screenshot carefully. There is a table or spreadsheet visible.
Extract ALL the data from the visible table into a structured JSON format.
Return ONLY a JSON object with this structure:
{
  "headers": ["Column1", "Column2", ...],
  "rows": [["value1", "value2", ...], ...]
}
Include every visible row. Do not summarize or skip any data."""
                },
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}
                }
            ]
        }],
        reasoning={"effort": "high"}
    )

    # Parse the JSON response
    response_text = response.output_text
    # Clean up markdown code fences if present
    if "```json" in response_text:
        response_text = response_text.split("```json")[1].split("```")[0]
    elif "```" in response_text:
        response_text = response_text.split("```")[1].split("```")[0]

    import json
    data = json.loads(response_text.strip())

    # Write to CSV
    with open(output_file, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(data["headers"])
        writer.writerows(data["rows"])

    row_count = len(data["rows"])
    col_count = len(data["headers"])
    print(f"Extracted {row_count} rows x {col_count} columns to {output_file}")
    return output_file


def extract_multi_page_data(output_file="full_data.csv", max_pages=10):
    """
    Extract data from a table that spans multiple pages.
    Scrolls down and extracts each page, then combines results.
    """
    all_rows = []
    headers = None

    for page in range(max_pages):
        print(f"Extracting page {page + 1}...")
        screenshot_b64 = take_screenshot()

        prompt = "Extract ALL table data visible on screen as JSON: {\"headers\": [...], \"rows\": [[...], ...]}"
        if page > 0:
            prompt += " Do NOT include the header row if it is repeated from the previous page."

        response = client.responses.create(
            model="gpt-5.4",
            input=[{
                "role": "user",
                "content": [
                    {"type": "text", "text": prompt},
                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}}
                ]
            }],
            reasoning={"effort": "high"}
        )

        response_text = response.output_text
        if "```json" in response_text:
            response_text = response_text.split("```json")[1].split("```")[0]
        elif "```" in response_text:
            response_text = response_text.split("```")[1].split("```")[0]

        import json
        data = json.loads(response_text.strip())

        if headers is None:
            headers = data["headers"]

        if not data["rows"]:
            print("No more data found. Stopping.")
            break

        all_rows.extend(data["rows"])
        print(f"  Found {len(data['rows'])} rows (total: {len(all_rows)})")

        # Scroll down for next page
        pyautogui.scroll(-5)
        time.sleep(1.0)

    # Write combined CSV
    with open(output_file, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(headers)
        writer.writerows(all_rows)

    print(f"\nDone. Extracted {len(all_rows)} total rows to {output_file}")
    return output_file


if __name__ == "__main__":
    print("Make sure a spreadsheet or table is visible on your screen.")
    print("Starting extraction in 3 seconds...")
    time.sleep(3)
    extract_table_data()

Hvordan bruke det:

1. Åpne et regneark, en databasevisning eller hvilken som helst app med tabelldata synlig på skjermen
2. Kjør python extract_data.py
3. Sjekk den genererte extracted_data.csv for det uthentede innholdet

For tabeller som strekker seg over flere sider, kall extract_multi_page_data() i stedet. Den vil automatisk rulle ned og kombinere alle sidene til én enkelt CSV.

---

Beste praksis for sikkerhet

Computer Use gir GPT-5.4 evnen til å kontrollere musen og tastaturet ditt. Den kraften krever forsiktighet.

Bruk alltid sandkasse først. Før du kjører noen automatisering på ditt reelle skrivebord, test i en virtuell maskin eller en Docker container med en virtuell skjerm. Dette isolerer feil og forhindrer utilsiktet skade.

Gå gjennom handlinger før utførelse. Endre execute_action funksjonen til å skrive ut hver handling og vente på din bekreftelse før den utføres:

def execute_action_safe(action):
    """Execute action only after user confirmation."""
    print(f"  Proposed action: {action.type}", end="")
    if hasattr(action, "x"):
        print(f" at ({action.x}, {action.y})", end="")
    if hasattr(action, "text"):
        print(f" text='{action.text[:30]}'", end="")
    print()

    confirm = input("  Execute? (y/n): ").strip().lower()
    if confirm == "y":
        execute_action(action)
    else:
        print("  Skipped.")

Sett hastighetsbegrensninger. Legg til et maksimalt antall handlinger per økt og et maksimalt kostnadsbudsjett. max_steps parameteren i run_automation begrenser allerede antall runder i løkken. Du kan også spore token-bruk fra response-objektet for å overvåke kostnader.

Aldri automatiser sensitive kontoer uten tilsyn. Ikke pek Computer Use mot bankappen din, e-post med sensitive data eller administrasjonskonsoller uten å overvåke hver eneste handling. GPT-5.4 kan klikke feil, feiltolke UI-elementer eller ta uforutsette veier.

Bruk PyAutoGUI sin fail-safe. Med pyautogui.FAILSAFE = True (som er standard), kan du avbryte enhver automatisering ved å raskt bevege musen til øverste venstre hjørne av skjermen. Ha dette aktivert til enhver tid.

---

Feilsøking av vanlige problemer

"Modellen returnerer ingen handlinger" -- Sørg for at du bruker computer_use_preview som verktøytype, ikke bare computer_use. Verifiser også at display_width og display_height samsvarer med din faktiske skjermoppløsning. Hvis verdiene er feil, kan det hende at GPT-5.4 ikke klarer å tolke skjermbildet korrekt.

"Klikk lander på feil posisjon" -- Dette skjer vanligvis på skjermer med skalering (f.eks. Retina-skjermer på macOS). PyAutoGUI jobber i pikselkoordinater, men skjermen din kan bruke logiske koordinater. Prøv å fange oppløsningen din med pyautogui.size() og sammenlign den med din faktiske pikseloppløsning. På macOS med Retina må du kanskje dele koordinatene på skaleringsfaktoren din.

"PyAutoGUI finner ikke skjermen" -- På hodeløse Linux servere, installer og start Xvfb: Xvfb :99 -screen 0 1920x1080x24 & og deretter export DISPLAY=:99. På macOS må du gi Terminal (eller din IDE) tilgangstillatelser i Systeminnstillinger > Personvern og sikkerhet > Tilgjengelighet.

"API returnerer en 429 rate limit feil" -- Legg til en time.sleep(2) mellom API kall, eller implementer eksponentiell ventetid (backoff). GPT-5.4 Computer Use-økter kan nå rate limits hvis du sender skjermbilder for raskt.

"Høye token-kostnader" -- Skjermbilder i full oppløsning bruker mange tokens. Reduser kostnadene ved å endre størrelsen på skjermbildene før du koder dem:

def take_screenshot_resized(max_width=1280):
    screenshot = pyautogui.screenshot()
    ratio = max_width / screenshot.width
    new_size = (max_width, int(screenshot.height * ratio))
    screenshot = screenshot.resize(new_size)
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8"), ratio

Når du bruker skjermbilder med endret størrelse, husk å multiplisere GPT-5.4 sine returnerte koordinater med den omvendte brøken av ratio før du sender dem til PyAutoGUI.

"GPT-5.4 sitter fast i en løkke" -- Hvis modellen fortsetter å gjenta den samme handlingen, kan den være forvirret av UI-tilstanden. Legg til logikk for å oppdage gjentatte handlinger og bryte løkken, eller øk resonneringsinnsatsen til "high" for bedre beslutningstaking.

---

Veien videre

Når du har den grunnleggende automatiseringsløkken i gang, er her noen måter å utvide den på:

Koble sammen flere oppgaver. Bygg en arbeidsflyt som åpner e-posten din, laster ned et vedlegg, åpner det i et regneark, henter ut spesifikke celler og limer verdiene inn i en rapportmal. Hvert steg bruker den samme løkken med skjermbilde-analyse-handling.

Legg til feilhåndtering. Sjekk hvert skjermbilde for feildialoger eller uventede tilstander. Hvis GPT-5.4 oppdager at noe gikk galt, kan den forsøke å gjenopprette ved å klikke på "Avbryt", trykke Escape eller prøve den forrige handlingen på nytt.

Kombiner med Playwright for nettleseroppgaver. For automatisering som kun foregår på nett, kan GPT-5.4 også skrive Playwright kode for å samhandle med nettlesere programmatisk. Dette er raskere og mer pålitelig enn skjermbildebasert klikking for strukturerte nettsider. Bruk Computer Use for skrivebordsapper og Playwright for nettleserautomatisering.

Bygg et oppgavebibliotek. Lagre vanlige prompter og arbeidsflyter som gjenbrukbare funksjoner. Opprett en tasks/ mappe med skript som fill_invoice.py, export_report.py, og update_crm.py som teamet ditt kan kjøre ved behov.

Planlegg automatiseringer. Bruk cron (Linux/macOS) eller Oppgaveplanlegger (Windows) for å kjøre automatiseringsskriptene dine til faste tider. Kombiner med en virtuell skjerm for fullstendig hodeløs drift.

GPT-5.4 Computer Use er fortsatt en ny funksjon, og API-overflaten vil utvikle seg. Hold openai pakken din oppdatert med pip install --upgrade openai for å få de nyeste verktøytypene og parameterne etter hvert som OpenAI forbedrer funksjonen.

Koden i denne veiledningen gir deg et fungerende fundament. Start med enkle oppgaver med lav risiko, valider at automatiseringen fungerer som den skal, og skaler deretter opp til mer komplekse arbeidsflyter etter hvert som du bygger tillit til systemet.