Keskeiset asiat

• Kuvakaappaus-toiminto-silmukka on ydintoimintamalli: Skriptisi ottaa kuvakaappauksen, lähettää sen GPT-5.4:lle Responses API:n kautta computer_use käytössä, vastaanottaa rakenteisia toimintokomentoja (click, type, scroll) ja suorittaa ne PyAutoGUI:lla silmukassa.
• GPT-5.4 voitti ihmisasiantuntijat OSWorld-testissä tuloksella 75 %: Tämä on ensimmäinen AI-malli, joka ylittää ihmisen suoritustason työpöytäautomaation benchmark-testeissä, tehden käytännön automaatiosta elinkelpoista todellisissa työnkuluissa.
• Kustannukset ovat yllättävän alhaiset: Tyypillinen automaatiosessio 10-20 kuvakaappauksella maksaa $0.10-0.50, laskutettuna GPT-5.4:n vakiotaksoilla (~$10/$30 per miljoona syöte-/tuloste-tokenia).
• Turvallisuus vaatii koodisi suorittavan toiminnot: GPT-5.4 lähettää vain toimintokomentoja — sovelluksesi päättää, suoritetaanko ne, mikä tekee hiekkalaatikkotestauksesta ja toimintojen tarkistamisesta välttämätöntä ennen valvomattoman käytön aloittamista.
• Kolme edellytystä aloittamiseen: Python 3.10+, OpenAI API-avain Tier 1 -pääsyllä (vähintään $5 aiempi kulutus) ja työpöytäympäristö näytöllä.

GPT-5.4 sai 75 % tuloksen OSWorld-benchmarkissa, voittaen ihmisasiantuntijat työpöytäautomaatiossa ensimmäistä kertaa. Mutta benchmark-tulosten tietäminen ja Computer Use -ominaisuuden varsinainen käyttäminen itse ovat kaksi eri asiaa.

Tämä opas kuroo umpeen tuon kuilun. Lopuksi sinulla on toimiva Python-skripti, joka ottaa kuvakaappauksia työpöydästäsi, lähettää ne GPT-5.4:lle, vastaanottaa rakenteisia toimintokomentoja ja suorittaa ne automaattisesti. Ei teoriaa, ei hypetystä — vain koodia, jota voit ajaa tänään.

---

Mitä rakennat

Rakennat täydellisen työpöytäautomaatiosilmukan, joka toimii näin:

1. Skriptisi ottaa kuvakaappauksen näytöstäsi
2. Se lähettää kuvakaappauksen GPT-5.4:lle OpenAI Responses API:n kautta computer_use-työkalu käytössä
3. GPT-5.4 analysoi kuvakaappauksen ja palauttaa rakenteisia toimintoja (click, type, scroll, keypress)
4. Skriptisi suorittaa nuo toiminnot käyttämällä PyAutoGUI-kirjastoa
5. Silmukka toistuu, kunnes tehtävä on valmis

Tämän opetusohjelman lopussa sinulla on kaksi toimivaa esimerkkiä: yksi, joka täyttää verkkolomakkeen automaattisesti, ja toinen, joka poimii dataa työpöytäsovelluksesta CSV-tiedostoon.

---

Esivaatimukset

Ennen kuin aloitat, varmista, että sinulla on seuraavat:

• Python 3.10 tai uudempi asennettuna koneellasi
• OpenAI API-avain, jolla on pääsy GPT-5.4-malliin (vaatii maksullisen tilin, jolla on vähintään Tier 1 -pääsy — vähintään $5 aiempi kulutus)
• Työpöytäympäristö — Computer Use toimii macOS-, Windows- ja Linux-käyttöjärjestelmissä, joissa on näyttö. Headless-palvelimilla tarvitset virtuaalisen näytön, kuten Xvfb
• Perustiedot Python-kielestä (sinun ei tarvitse olla asiantuntija — kaikki koodi toimitetaan)

---

Vaihe 1: Ympäristön määrittäminen

Aloita luomalla projektihakemisto ja asentamalla tarvittavat paketit.

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

pip install openai pyautogui pillow

Mitä kukin paketti tekee:

• openai — Virallinen OpenAI Python SDK GPT-5.4 API:n kutsumiseen
• pyautogui — Alustariippumaton kirjasto hiiren ja näppäimistön hallintaan
• pillow — Kuvankäsittelykirjasto kuvakaappausten hallintaan

Aseta seuraavaksi API-avaimesi ympäristömuuttujaksi:

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

Käytä Windowsissa komentoa set OPENAI_API_KEY=sk-your-api-key-here sen sijaan.

Luo tiedosto nimeltä automation.py ja lisää siihen perusmääritykset:

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

client = OpenAI()  # Lukee OPENAI_API_KEY:n ympäristöstä

# Turvallisuus: lisää lyhyt tauko ennen toimintoja, jotta voit siirtää hiiren
# kulmaan aktivoidaksesi PyAutoGUI:n fail-safe-toiminnon ja keskeyttääksesi
pyautogui.PAUSE = 0.5
pyautogui.FAILSAFE = True

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

Aja tämä varmistaaksesi, että kaikki on asennettu oikein:

python automation.py

Sinun pitäisi nähdä näyttösi resoluutio tulostettuna. Jos saat import-virheitä, tarkista, että aktivoit virtuaaliympäristön ja asensit kaikki paketit.

---

Vaihe 2: Ota kuvakaappaus

Computer Use toimii analysoimalla kuvakaappauksia. Koodisi kaappaa näytön ja muuntaa sen base64-koodatuksi merkkijonoksi, jonka API voi vastaanottaa.

Lisää tämä funktio tiedostoon 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")

Testaa sitä lisäämällä nopea tarkistus tiedoston loppuun:

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

Tämän pitäisi tulostaa jotain tyyliin Screenshot captured: 2847392 characters (base64). Tarkka luku riippuu näyttösi resoluutiosta ja siitä, mitä näytöllä näkyy.

---

Vaihe 3: Lähetä kuvakaappaus GPT-5.4:lle

Nyt tulee Computer Use -toiminnon ydin: kuvakaappauksen lähettäminen GPT-5.4:lle computer_use-työkalu käytössä ja rakenteisten toimintokomentojen vastaanottaminen vastauksena.

Lisää tämä funktio:

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

Tärkeimmät parametrit selitettynä:

• computer_use_preview — Kertoo GPT-5.4:lle, että sen tulee analysoida kuvakaappaus ja palauttaa työpöytätoimintoja
• display_width / display_height — Näyttösi resoluutio, jotta GPT-5.4 palauttaa koordinaatit, jotka vastaavat todellista näyttöäsi
• environment — Aseta arvoksi "mac", "windows" tai "linux", jotta GPT-5.4 käyttää oikeita pikanäppäimiä ja UI-käytäntöjä
• reasoning.effort — Määrittää, kuinka paljon GPT-5.4 käyttää päättelyä. Käytä "medium" vakiotehtäviin, "high" monimutkaisiin monivaiheisiin työnkulkuihin
• previous_response_id — Ketjuttaa useita kutsuja yhteen, jotta GPT-5.4 muistaa, mitä se on jo tehnyt

---

Vaihe 4: Suorita toiminnot

GPT-5.4 palauttaa vastauksessaan rakenteisia toimintokomentoja. Sinun on jäsennettävä nämä ja suoritettava ne PyAutoGUI-kirjastolla.

Lisää toimintojen suorittaja:

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

Tämä käsittelee kaikki toimintotyypit, joita GPT-5.4 voi palauttaa: klikkaus, kaksoisklikkaus, kirjoittaminen, näppäinpainallukset, vieritys ja raahaaminen.

---

Vaihe 5: Rakenna automaatiosilmukka

Yhdistä nyt kaikki täydelliseksi automaatiosilmukaksi. Tämä on päämoottori, joka suorittaa tehtäväsi:

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

Voit nyt suorittaa minkä tahansa automaatiotehtävän yhdellä funktiokutsulla:

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

Tämä ottaa kuvakaappauksen näytöstäsi, lähettää sen GPT-5.4:lle, ja GPT-5.4 keksi miten avata Laskin ja suorittaa kertolasku — klikkaamalla painikkeita, lukemalla tuloksen ja pysähtyen, kun se on valmis.

---

Käytännön esimerkki 1: Verkkolomakkeen automaattinen täyttö

Tässä on täydellinen toimiva esimerkki, joka täyttää verkkoyhteydenottolomakkeen. Tallenna tämä nimellä 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()

Miten sitä käytetään:

1. Avaa verkkosivu, jossa on yhteydenottolomake, selaimessasi
2. Varmista, että lomake on täysin näkyvissä näytöllä (ei tarvetta vieritykselle ensimmäisille kentille)
3. Aja python autofill_form.py
4. Seuraa, kuinka GPT-5.4 tunnistaa jokaisen kentän, klikkaa sitä ja kirjoittaa oikean arvon

---

Käytännön esimerkki 2: Datan poimiminen työpöytäsovelluksesta

Tämä esimerkki lukee dataa näkyvissä olevasta taulukkolaskenta- tai taulukkosovelluksesta ja tallentaa sen CSV-tiedostoon. Tallenna tämä nimellä 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()

Miten sitä käytetään:

1. Avaa taulukkolaskentaohjelma, tietokantakatselin tai mikä tahansa sovellus, jossa on taulukkomuotoista dataa näkyvissä
2. Aja python extract_data.py
3. Tarkista generoitu extracted_data.csv poimitun sisällön osalta

Jos taulukot jatkuvat useille sivuille, kutsu extract_multi_page_data() sen sijaan. Se vierittää automaattisesti ja yhdistää kaikki sivut yhdeksi CSV-tiedostoksi.

---

Turvallisuuden parhaat käytännöt

Computer Use antaa GPT-5.4:lle kyvyn hallita hiirtäsi ja näppäimistöäsi. Tuo valta vaatii varovaisuutta.

Käytä aina ensin hiekkalaatikkoa (sandbox). Ennen kuin ajat automaatiota varsinaisella työpöydälläsi, testaa sitä virtuaalikoneessa tai Docker-kontissa, jossa on virtuaalinen näyttö. Tämä eristää virheet ja estää vahingot.

Tarkista toiminnot ennen suorittamista. Muokkaa execute_action-funktiota tulostamaan jokainen toiminto ja odottamaan vahvistustasi ennen suorittamista:

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

Aseta rajoituksia. Lisää enimmäismäärä toiminnoille per sessio ja maksimikustannusbudjetti. run_automation-funktion max_steps-parametri rajoittaa jo silmukan kierroksia. Voit myös seurata token-kulutusta vastausobjektista kustannusten tarkkailemiseksi.

Älä koskaan automatisoi arkaluonteisia tilejä ilman valvontaa. Älä kohdista Computer Use -toimintoa pankkisovellukseesi, arkaluonteista dataa sisältävään sähköpostiisi tai hallintapaneeleihin seuraamatta jokaista toimintoa. GPT-5.4 voi klikata väärin, lukea käyttöliittymäelementtejä väärin tai ottaa tahattomia polkuja.

Käytä PyAutoGUI:n fail-safe-toimintoa. Kun pyautogui.FAILSAFE = True (mikä on oletusarvo), voit keskeyttää minkä tahansa automaation siirtämällä hiiren nopeasti näytön vasempaan yläkulmaan. Pidä tämä käytössä kaikkina aikoina.

---

Yleisten ongelmien vianmääritys

"Malli ei palauta mitään toimintoja" -- Varmista, että käytät computer_use_preview työkalutyyppinä, etkä vain computer_use. Varmista myös, että display_width ja display_height vastaavat todellista näyttösi resoluutiota. Jos arvot ovat väärin, GPT-5.4 ei ehkä pysty tulkitsemaan kuvakaappausta oikein.

"Klikkaukset osuvat väärään kohtaan" -- Tämä tapahtuu yleensä näytöillä, joissa on skaalaus (esim. Retina-näytöt macOS:ssä). PyAutoGUI toimii pikselikoordinaateilla, mutta näyttösi saattaa käyttää loogisia koordinaatteja. Kokeile resoluution kaappaamista pyautogui.size() -komennolla ja vertaa sitä todelliseen pikseliresoluutioon. macOS:ssä Retina-näytöllä saatat joutua jakamaan koordinaatit skaalauskertoimellasi.

"PyAutoGUI ei löydä näyttöä" -- Headless Linux -palvelimilla asenna ja käynnistä Xvfb: Xvfb :99 -screen 0 1920x1080x24 & ja sitten export DISPLAY=:99. macOS:ssä sinun on annettava Terminalille (tai IDE:llesi) käyttöoikeudet kohdassa System Settings > Privacy & Security > Accessibility.

"API palauttaa 429 rate limit -virheen" -- Lisää time.sleep(2) API-kutsujen välille tai toteuta eksponentiaalinen perääntyminen (exponential backoff). GPT-5.4 Computer Use -sessiot voivat saavuttaa rate limit -rajat, jos lähetät kuvakaappauksia liian nopeasti.

"Korkeat token-kustannukset" -- Täyden resoluution kuvakaappaukset kuluttavat paljon tokeneita. Vähennä kustannuksia muuttamalla kuvakaappausten kokoa ennen niiden koodaamista:

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

Käyttäessäsi pienennettyjä kuvakaappauksia, muista kertoa GPT-5.4:n palauttamat koordinaatit kertoimen käänteisluvulla ennen niiden välittämistä PyAutoGUI:lle.

"GPT-5.4 juuttuu silmukkaan" -- Jos malli toistaa samaa toimintoa jatkuvasti, se saattaa olla hämmentynyt käyttöliittymän tilasta. Lisää logiikkaa tunnistamaan toistuvat toiminnot ja katkaisemaan silmukka, tai nosta reasoning-panostus tasolle "high" parempaa päätöksentekoa varten.

---

Mitä seuraavaksi

Kun perusautomaatiosilmukka toimii, tässä on tapoja laajentaa sitä:

Ketjuta useita tehtäviä. Rakenna työnkulku, joka avaa sähköpostisi, lataa liitteen, avaa sen taulukkolaskentaohjelmassa, poimii tietyt solut ja liittää arvot raporttipohjaan. Jokainen vaihe käyttää samaa kuvakaappaus-analyysi-toiminto-silmukkaa.

Lisää virheenpalautus. Tarkista jokainen kuvakaappaus virheilmoitusten tai odottamattomien tilojen varalta. Jos GPT-5.4 huomaa jonkin menneen vikaan, se voi yrittää palautua klikkaamalla "Peruuta", painamalla Escape-näppäintä tai yrittämällä viimeisintä toimintoa uudelleen.

Yhdistä Playwright-kirjastoon selain-tehtäviä varten. Pelkästään verkkoon liittyvää automaatiota varten GPT-5.4 voi myös kirjoittaa Playwright-koodia vuorovaikutukseen selainten kanssa ohjelmallisesti. Tämä on nopeampaa ja luotettavampaa kuin kuvakaappaukseen perustuva klikkailu rakenteisilla verkkosivuilla. Käytä Computer Use -ominaisuutta työpöytäsovelluksiin ja Playwrightia selainautomaatioon.

Rakenna tehtäväkirjasto. Tallenna yleiset kehotteet (prompts) ja työnkulut uudelleenkäytettäviksi funktioiksi. Luo tasks/-hakemisto, jossa on skriptejä kuten fill_invoice.py, export_report.py ja update_crm.py, joita tiimisi voi ajaa tarvittaessa.

Ajasta automaatiot. Käytä cron-työkalua (Linux/macOS) tai Task Scheduleria (Windows) ajaaksesi automaatioskriptit asetettuina aikoina. Yhdistä virtuaaliseen näyttöön täysin headless-toimintaa varten.

GPT-5.4 Computer Use on vielä uusi ominaisuus, ja API-pinta tulee kehittymään. Pidä openai-pakettisi ajan tasalla komennolla pip install --upgrade openai saadaksesi uusimmat työkalutyypit ja parametrit, kun OpenAI hioo ominaisuutta.

Tämän opetusohjelman koodi antaa sinulle toimivan perustan. Aloita yksinkertaisista, vähäriskisistä tehtävistä, varmista, että automaatio toimii oikein, ja laajenna sitten monimutkaisempiin työnkulkuihin, kun luottamuksesi järjestelmään kasvaa.