Vigtigste pointer

• Screenshot-action loop er det centrale mønster: Dit script tager et screenshot, sender det til GPT-5.4 via Responses API med computer_use aktiveret, modtager strukturerede handlingskommandoer (click, type, scroll) og udfører dem med PyAutoGUI i et loop.
• GPT-5.4 slog menneskelige eksperter på OSWorld med 75%: Dette er den første AI model, der overgår menneskelig præstation på benchmarks for desktop automation, hvilket gør praktisk automatisering levedygtig for reelle workflows.
• Omkostningerne er overraskende lave: En typisk automatiseringssession med 10-20 screenshots koster $0.10-0.50, afregnet efter GPT-5.4's standardpriser (~$10/$30 pr. million input/output tokens).
• Sikkerhed kræver, at din kode udfører handlinger: GPT-5.4 sender kun handlingskommandoer -- din applikation beslutter, om de skal udføres, hvilket gør sandboxed testning og gennemgang af handlinger essentielt, før de køres uden opsyn.
• Tre forudsætninger for at komme i gang: Python 3.10+, en OpenAI API nøgle med Tier 1 adgang (minimum $5 tidligere forbrug) og et desktop-miljø med en skærm.

GPT-5.4 scorede 75% på OSWorld benchmarken og slog for første gang menneskelige eksperter i desktop automation. Men at kende benchmark-resultaterne og rent faktisk selv at bruge Computer Use er to meget forskellige ting.

Denne guide bygger bro over den kløft. Ved slutningen vil du have et fungerende Python script, der tager screenshots af dit skrivebord, sender dem til GPT-5.4, modtager strukturerede handlingskommandoer og udfører dem automatisk. Ingen teori, ingen hype — kun kode du kan køre i dag.

---

Hvad du vil bygge

Du vil bygge et komplet desktop automation loop, der fungerer således:

1. Dit script tager et screenshot af din skærm
2. Det sender det screenshot til GPT-5.4 via OpenAI Responses API med computer_use værktøjet aktiveret
3. GPT-5.4 analyserer dit screenshot og returnerer strukturerede handlinger (click, type, scroll, keypress)
4. Dit script udfører disse handlinger ved hjælp af PyAutoGUI
5. Loopet gentages, indtil opgaven er fuldført

Ved slutningen af denne tutorial vil du have to fungerende eksempler: et der auto-udfylder en webformular, og et der udtrækker data fra en desktop-applikation til en CSV fil.

---

Forudsætninger

Før du starter, skal du sikre dig, at du har følgende:

• Python 3.10 eller nyere installeret på din maskine
• En OpenAI API nøgle med adgang til GPT-5.4 (kræver en betalt konto med mindst Tier 1 adgang — minimum $5 tidligere forbrug)
• Et desktop-miljø — Computer Use fungerer på macOS, Windows og Linux med en skærm. For headless servere skal du bruge en virtuel skærm som Xvfb
• Grundlæggende kendskab til Python (du behøver ikke at være ekspert — alt kode er leveret)

---

Trin 1: Opsæt dit miljø

Start med at oprette en projektmappe og installer de nødvendige pakker.

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

Hvad hver pakke gør:

• openai — Officiel OpenAI Python SDK til at kalde GPT-5.4 API
• pyautogui — Cross-platform bibliotek til at styre mus og tastatur
• pillow — Billedbehandlingsbibliotek til håndtering af screenshots

Derefter skal du indstille din API nøgle som en miljøvariabel:

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

På Windows skal du bruge set OPENAI_API_KEY=sk-your-api-key-here i stedet.

Opret en fil kaldet automation.py og tilføj den grundlæggende opsætning:

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}")

Kør dette for at bekræfte, at alt er installeret korrekt:

python automation.py

Du bør se din skærmopløsning blive udskrevet. Hvis du får import-fejl, skal du dobbelttjekke, at du har aktiveret det virtuelle miljø og installeret alle pakker.

---

Trin 2: Tag et screenshot

Computer Use fungerer ved at analysere screenshots. Din kode fanger skærmen og konverterer den til en base64-kodet streng, som API'et kan modtage.

Tilføj denne funktion til 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 at tilføje et hurtigt tjek i bunden af filen:

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

Dette bør udskrive noget i retning af Screenshot captured: 2847392 characters (base64). Det præcise tal afhænger af din skærmopløsning og hvad der er på skærmen.

---

Trin 3: Send et screenshot til GPT-5.4

Nu kommer kernen i Computer Use: at sende et screenshot til GPT-5.4 med computer_use værktøjet aktiveret, og modtage strukturerede handlingskommandoer retur.

Tilføj denne funktion:

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

Vigtige parametre forklaret:

• computer_use_preview — Fortæller GPT-5.4, at den skal analysere screenshotet og returnere desktop-handlinger
• display_width / display_height — Din skærmopløsning, så GPT-5.4 returnerer koordinater, der matcher din faktiske skærm
• environment — Indstillet til "mac", "windows", eller "linux", så GPT-5.4 bruger de rigtige tastaturgenveje og UI-konventioner
• reasoning.effort — Styrer hvor meget GPT-5.4 ræsonnerer. Brug "medium" til standardopgaver, "high" til komplekse multi-trins workflows
• previous_response_id — Kæder flere kald sammen, så GPT-5.4 husker, hvad den allerede har gjort

---

Trin 4: Udfør handlinger

GPT-5.4 returnerer strukturerede handlingskommandoer i sit svar. Du skal parse disse og udføre dem med PyAutoGUI.

Tilføj handlingseksekveren:

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 de handlingstyper, som GPT-5.4 kan returnere: klik, dobbeltklik, skrivning, tastetryk, scroll og træk (drag).

---

Trin 5: Byg automatiserings-loopet

Nu bindes det hele sammen til et komplet automatiserings-loop. Dette er hovedmotoren, der kører dine opgaver:

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 nu køre enhver automatiseringsopgave med et enkelt funktionskald:

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

Dette vil fange din skærm, sende den til GPT-5.4, og GPT-5.4 vil finde ud af, hvordan man åbner Calculator og udfører multiplikationen — klikke på knapper, læse resultatet og stoppe, når det er færdigt.

---

Praktisk eksempel 1: Auto-udfyld en webformular

Her er et komplet fungerende eksempel, der udfylder en kontaktformular på nettet. Gem denne 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 man bruger det:

1. Åbn en webside med en kontaktformular i din browser
2. Sørg for, at formularen er fuldt synlig på skærmen (ingen scroll nødvendig for de første felter)
3. Kør python autofill_form.py
4. Se mens GPT-5.4 identificerer hvert felt, klikker på det og skriver den korrekte værdi

---

Praktisk eksempel 2: Udtræk data fra en desktop-app

Dette eksempel læser data fra et synligt regneark eller en tabel-applikation og gemmer dem i en CSV fil. Gem denne 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 man bruger det:

1. Åbn et regneark, en database-viewer eller en hvilken som helst app med tabeldata synlige på skærmen
2. Kør python extract_data.py
3. Tjek den genererede extracted_data.csv for det udtrukne indhold

For tabeller, der strækker sig over flere sider, skal du kalde extract_multi_page_data() i stedet. Den vil automatisk scrolle og kombinere alle sider til en enkelt CSV.

---

Best practices for sikkerhed

Computer Use giver GPT-5.4 muligheden for at styre din mus og dit tastatur. Den kraft kræver forsigtighed.

Brug altid sandbox først. Før du kører automatisering på dit rigtige skrivebord, skal du teste i en virtuel maskine eller en Docker container med en virtuel skærm. Dette isolerer fejl og forhindrer utilsigtet skade.

Gennemse handlinger før eksekvering. Rediger execute_action funktionen til at udskrive hver handling og vente på din bekræftelse, før den udfø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.")

Indstil rate limits. Tilføj et maksimalt antal handlinger pr. session og et maksimalt budget. max_steps parameteren i run_automation begrænser allerede antallet af loops. Du kan også spore token-forbrug fra response-objektet for at overvåge omkostningerne.

Automatiser aldrig følsomme konti uden opsyn. Ret ikke Computer Use mod din bank-app, e-mail med følsomme data eller administrationskonsoller uden at overvåge hver eneste handling. GPT-5.4 kan klikke forkert, misforstå UI-elementer eller tage utilsigtede veje.

Brug PyAutoGUI's fail-safe. Med pyautogui.FAILSAFE = True (hvilket er standard), kan du afbryde enhver automatisering ved hurtigt at flytte din mus til det øverste venstre hjørne af skærmen. Hold dette aktiveret hele tiden.

---

Fejlfinding af almindelige problemer

"Model returnerer ingen handlinger" -- Sørg for, at du bruger computer_use_preview som værktøjstype, ikke bare computer_use. Bekræft også, at dine display_width og display_height matcher din faktiske skærmopløsning. Hvis værdierne er forkerte, er GPT-5.4 muligvis ikke i stand til at fortolke screenshotet korrekt.

"Klik lander det forkerte sted" -- Dette sker normalt på skærme med skalering (f.eks. Retina-skærme på macOS). PyAutoGUI arbejder i pixel-koordinater, men din skærm bruger muligvis logiske koordinater. Prøv at fange din opløsning med pyautogui.size() og sammenlign den med din faktiske pixelopløsning. På macOS med Retina skal du muligvis dividere koordinaterne med din skaleringsfaktor.

"PyAutoGUI kan ikke finde skærmen" -- På headless Linux servere skal du installere og starte Xvfb: Xvfb :99 -screen 0 1920x1080x24 & derefter export DISPLAY=:99. På macOS skal du give Terminal (eller din IDE) adgangstilladelser i Systemindstillinger > Anonymitet og sikkerhed > Tilgængelighed.

"API returnerer en 429 rate limit fejl" -- Tilføj en time.sleep(2) mellem API-kald, eller implementer exponential backoff. GPT-5.4 Computer Use sessioner kan ramme rate limits, hvis du sender screenshots for hurtigt.

"Høje token-omkostninger" -- Screenshots i fuld opløsning bruger mange tokens. Reducer omkostningerne ved at ændre størrelsen på screenshots, 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 bruger screenshots med ændret størrelse, skal du huske at multiplicere GPT-5.4's returnerede koordinater med det omvendte af ratioen, før du sender dem til PyAutoGUI.

"GPT-5.4 sidder fast i et loop" -- Hvis modellen bliver ved med at gentage den samme handling, kan den være forvirret over UI-tilstanden. Tilføj logik til at detektere gentagne handlinger og bryde loopet, eller øg ræsonneringsindsatsen til "high" for bedre beslutningstagning.

---

Hvad nu?

Når du har det grundlæggende automatiserings-loop til at fungere, er her måder at udvide det på:

Kæd flere opgaver sammen. Byg et workflow, der åbner din e-mail, downloader en vedhæftet fil, åbner den i et regneark, udtrækker specifikke celler og indsætter værdierne i en rapportskabelon. Hvert trin bruger det samme screenshot-analyze-act loop.

Tilføj fejlhåndtering. Tjek hvert screenshot for fejldialoger eller uventede tilstande. Hvis GPT-5.4 opdager, at noget gik galt, kan den forsøge at rette det ved at klikke "Annuller", trykke på Escape eller prøve den sidste handling igen.

Kombiner med Playwright til browser-opgaver. For automatisering udelukkende på nettet kan GPT-5.4 også skrive Playwright-kode for at interagere med browsere programmatisk. Dette er hurtigere og mere pålideligt end screenshot-baserede klik for strukturerede websider. Brug Computer Use til desktop-apps og Playwright til browser-automatisering.

Byg et opgavebibliotek. Gem almindelige prompts og workflows som genanvendelige funktioner. Opret en tasks/ mappe med scripts som fill_invoice.py, export_report.py og update_crm.py, som dit team kan køre efter behov.

Planlæg automatiseringer. Brug cron (Linux/macOS) eller Task Scheduler (Windows) til at køre dine automatiseringsscripts på fastsatte tidspunkter. Kombiner med en virtuel skærm for fuldt headless drift.

GPT-5.4 Computer Use er stadig en ny funktion, og API'et vil udvikle sig. Hold din openai pakke opdateret med pip install --upgrade openai for at få de nyeste værktøjstyper og parametre, efterhånden som OpenAI forfiner funktionen.

Koden i denne tutorial giver dig et fungerende fundament. Start med enkle opgaver med lav risiko, bekræft at automatiseringen fungerer korrekt, og skaler derefter op til mere komplekse workflows, efterhånden som du opbygger tillid til systemet.