Főbb tanulságok

• A Screenshot-action loop a központi minta: A scripted készít egy screenshot-ot, elküldi a GPT-5.4 számára a Responses API-n keresztül, engedélyezett computer_use mellett, strukturált műveleti parancsokat kap (click, type, scroll), és végrehajtja azokat a PyAutoGUI segítségével egy ciklusban.
• A GPT-5.4 legyőzte az emberi szakértőket az OSWorld benchmarkon 75%-kal: Ez az első AI modell, amely felülmúlja az emberi teljesítményt az asztali automatizálási benchmarkokon, így a gyakorlati automatizálás életképessé válik a valódi munkafolyamatokhoz.
• A költség meglepően alacsony: Egy tipikus automatizálási munkamenet 10-20 screenshots beküldésével $0.10-0.50-ba kerül, a GPT-5.4 standard díjszabása szerint számlázva (~$10/$30 per millió input/output tokens).
• A biztonság megköveteli, hogy a kódod hajtsa végre a műveleteket: A GPT-5.4 csak műveleti parancsokat küld -- az alkalmazásod dönti el, hogy végrehajtja-e azokat, így a sandboxed testing és a műveletek felülvizsgálata elengedhetetlen a felügyelet nélküli futtatás előtt.
• Három előfeltétel az induláshoz: Python 3.10+, egy OpenAI API kulcs Tier 1 hozzáféréssel (minimum $5 korábbi költés), és egy asztali környezet kijelzővel.

A GPT-5.4 75%-ot ért el az OSWorld benchmarkon, első alkalommal győzve le az emberi szakértőket az asztali automatizálásban. De ismerni a benchmark eredményeket és ténylegesen használni a Computer Use funkciót két nagyon különböző dolog.

Ez az útmutató áthidalja ezt a szakadékot. A végére rendelkezni fogsz egy működő Python scripttel, amely screenshotokat készít az asztalodról, elküldi azokat a GPT-5.4-nek, strukturált műveleti parancsokat fogad, és automatikusan végrehajtja azokat. Semmi elmélet, semmi hájp — csak kód, amit még ma futtathatsz.

---

Amit építeni fogsz

Egy teljes asztali automatizálási ciklust fogsz építeni, amely így működik:

1. A scripted készít egy screenshot-ot a képernyődről
2. Elküldi ezt a screenshot-ot a GPT-5.4-nek az OpenAI Responses API-n keresztül, engedélyezett computer_use eszközzel
3. A GPT-5.4 elemzi a screenshot-ot, és strukturált műveleteket ad vissza (click, type, scroll, keypress)
4. A scripted végrehajtja ezeket a műveleteket a PyAutoGUI használatával
5. A ciklus ismétlődik, amíg a feladat be nem fejeződik

Az útmutató végére két működő példád lesz: egy, amely automatikusan kitölt egy webes űrlapot, és egy, amely adatokat nyer ki egy asztali alkalmazásból egy CSV fájlba.

---

Előfeltételek

Mielőtt elkezdenéd, győződj meg arról, hogy rendelkezel a következőkkel:

• Python 3.10 vagy újabb telepítve a gépeden
• Egy OpenAI API kulcs hozzáféréssel a GPT-5.4 modellhez (fizetős fiók szükséges legalább Tier 1 hozzáféréssel — minimum $5 korábbi költés)
• Egy asztali környezet — A Computer Use működik macOS, Windows és Linux rendszereken is, ha van kijelző. Headless szerverek esetén virtuális kijelzőre lesz szükséged, mint például az Xvfb
• Alapszintű jártasság a Python nyelvben (nem kell szakértőnek lenned — minden kódot biztosítunk)

---

1. lépés: A környezet beállítása

Kezdd egy projektkönyvtár létrehozásával és a szükséges csomagok telepítésével.

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

pip install openai pyautogui pillow

Mit csinálnak az egyes csomagok:

• openai — Hivatalos OpenAI Python SDK a GPT-5.4 API hívásához
• pyautogui — Platformfüggetlen könyvtár az egér és a billentyűzet vezérléséhez
• pillow — Képfeldolgozó könyvtár a screenshotok kezeléséhez

Ezután állítsd be az API kulcsodat környezeti változóként:

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

Windows-on használd a set OPENAI_API_KEY=sk-your-api-key-here parancsot.

Hozz létre egy automation.py nevű fájlt, és add hozzá az alapvető beállításokat:

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

client = OpenAI()  # Beolvassa az OPENAI_API_KEY-t a környezetből

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

Futtasd le, hogy ellenőrizd, minden megfelelően van-e telepítve:

python automation.py

Látnod kell a képernyőfelbontásodat kiírva. Ha importálási hibákat kapsz, ellenőrizd kétszer is, hogy aktiváltad-e a virtuális környezetet és telepítetted-e az összes csomagot.

---

2. lépés: Készíts egy screenshot-ot

A Computer Use a screenshotok elemzésével működik. A kódod rögzíti a képernyőt, és base64-kódolt karakterlánccá alakítja, amelyet az API el tud fogadni.

Add hozzá ezt a függvényt az automation.py fájlhoz:

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

Teszteld le egy gyors ellenőrzéssel a fájl alján:

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

Ennek valami ilyesmit kell kiírnia: Screenshot captured: 2847392 characters (base64). A pontos szám a képernyőfelbontásodtól és a képernyő tartalmától függ.

---

3. lépés: Screenshot küldése a GPT-5.4 számára

Most következik a Computer Use lényege: egy screenshot küldése a GPT-5.4-nek a computer_use eszköz engedélyezésével, és strukturált műveleti parancsok fogadása válaszként.

Add hozzá ezt a függvényt:

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

A legfontosabb paraméterek magyarázata:

• computer_use_preview — Megmondja a GPT-5.4-nek, hogy elemezze a screenshot-ot és adjon vissza asztali műveleteket
• display_width / display_height — A képernyőfelbontásod, hogy a GPT-5.4 a tényleges kijelződnek megfelelő koordinátákat adjon vissza
• environment — Állítsd be "mac", "windows" vagy "linux" értékre, hogy a GPT-5.4 a megfelelő billentyűkombinációkat és UI konvenciókat használja
• reasoning.effort — Szabályozza, hogy a GPT-5.4 mennyi érvelést végezzen. Használd a "medium" értéket standard feladatokhoz, és a "high" értéket komplex, többlépcsős munkafolyamatokhoz
• previous_response_id — Több hívást láncol össze, így a GPT-5.4 emlékszik arra, amit már korábban tett

---

4. lépés: Műveletek végrehajtása

A GPT-5.4 strukturált műveleti parancsokat ad vissza a válaszában. Ezeket értelmezned kell, és végre kell hajtanod a PyAutoGUI segítségével.

Add hozzá a művelet-végrehajtót:

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

Ez kezeli az összes olyan művelettípust, amelyet a GPT-5.4 visszaadhat: kattintás, dupla kattintás, gépelés, billentyűleütés, görgetés és húzás.

---

5. lépés: Az automatizálási ciklus felépítése

Most fűzz össze mindent egy teljes automatizálási ciklussá. Ez a fő motor, amely futtatja a feladataidat:

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

Most már bármilyen automatizálási feladatot futtathatsz egyetlen függvényhívással:

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

Ez rögzíteni fogja a képernyődet, elküldi a GPT-5.4-nek, és a GPT-5.4 kitalálja, hogyan nyissa meg a számológépet és végezze el a szorzást — gombokra kattintva, leolvasva az eredményt, és megállva, ha végzett.

---

1. gyakorlati példa: Webes űrlap automatikus kitöltése

Íme egy teljes, működő példa, amely kitölt egy webes kapcsolatfelvételi űrlapot. Mentse el ezt autofill_form.py néven:

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()

Hogyan használd:

1. Nyiss meg egy weboldalt egy kapcsolatfelvételi űrlappal a böngésződben
2. Győződj meg arról, hogy az űrlap teljesen látható a képernyőn (nincs szükség görgetésre az első mezőkhöz)
3. Futtasd a python autofill_form.py parancsot
4. Figyeld, ahogy a GPT-5.4 azonosítja az egyes mezőket, rákattint, és beírja a megfelelő értéket

---

2. gyakorlati példa: Adatok kinyerése egy asztali alkalmazásból

Ez a példa adatokat olvas ki egy látható táblázatkezelőből vagy táblázatos alkalmazásból, és CSV fájlba menti azokat. Mentse el ezt extract_data.py néven:

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()

Hogyan használd:

1. Nyiss meg egy táblázatot, adatbázis-nézegetőt vagy bármilyen olyan alkalmazást, amelyben táblázatos adatok láthatók a képernyőn
2. Futtasd a python extract_data.py parancsot
3. Ellenőrizd a létrehozott extracted_data.csv fájlt a kinyert tartalomért

Több oldalon átnyúló táblázatok esetén hívd meg helyette az extract_multi_page_data() függvényt. Ez automatikusan görgetni fog, és az összes oldalt egyetlen CSV-be összesíti.

---

Biztonsági ajánlások

A Computer Use képességet ad a GPT-5.4-nek az egér és a billentyűzet vezérléséhez. Ez a hatalom óvatosságot igényel.

Mindig sandoboxolj először. Mielőtt bármilyen automatizálást futtatnál a valódi asztalodon, teszteld virtuális gépen vagy Docker konténerben virtuális kijelzővel. Ez izolálja a hibákat és megelőzi a véletlen károkat.

Vizsgáld felül a műveleteket végrehajtás előtt. Módosítsd az execute_action függvényt úgy, hogy minden műveletet kiírjon, és várjon a megerősítésedre a végrehajtás előtt:

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

Állíts be sebességkorlátokat. Határozz meg egy maximális műveletszámot munkamenetenként és egy maximális költségkeretet. A run_automation függvényben lévő max_steps paraméter már korlátozza a ciklusok számát. A költségek nyomon követéséhez a válaszobjektumból a tokenfelhasználást is figyelheted.

Soha ne automatizálj érzékeny fiókokat felügyelet nélkül. Ne irányítsd a Computer Use-t banki alkalmazásod, érzékeny adatokat tartalmazó e-mailjeid vagy adminisztrációs konzolok felé anélkül, hogy minden egyes lépést figyelnél. A GPT-5.4 félrekattinthat, félreértelmezheti a UI elemeket, vagy nem szándékolt utakat választhat.

Használd a PyAutoGUI biztonsági funkcióját. A pyautogui.FAILSAFE = True beállítással (ami alapértelmezett), bármilyen automatizálást megszakíthatsz, ha gyorsan a képernyő bal felső sarkába mozgatod az egeret. Ezt tartsd mindig bekapcsolva.

---

Gyakori problémák elhárítása

"A modell nem ad vissza műveleteket" -- Győződj meg arról, hogy a computer_use_preview eszköztípust használod, nem csak a computer_use-t. Ellenőrizd azt is, hogy a display_width és display_height megegyezik-e a tényleges képernyőfelbontásoddal. Ha az értékek rosszak, a GPT-5.4 nem tudja helyesen értelmezni a screenshot-ot.

"A kattintások rossz pozícióba kerülnek" -- Ez általában skálázott kijelzőkön fordul elő (pl. Retina kijelzők macOS-en). A PyAutoGUI pixelkoordinátákkal dolgozik, de a kijelződ logikai koordinátákat használhat. Próbáld meg lekérdezni a felbontást a pyautogui.size() függvénnyel, és hasonlítsd össze a tényleges pixel-felbontással. macOS-en Retina kijelző esetén előfordulhat, hogy a koordinátákat el kell osztanod a skálázási faktorral.

"A PyAutoGUI nem találja a kijelzőt" -- Headless Linux szervereken telepítsd és indítsd el az Xvfb-t: Xvfb :99 -screen 0 1920x1080x24 &, majd export DISPLAY=:99. macOS-en engedélyezned kell a Terminal (vagy az IDE) számára a kisegítő lehetőségek hozzáférését a Rendszerbeállítások > Adatvédelem és biztonság > Kisegítő lehetőségek menüpontban.

"Az API 429 rate limit hibát ad vissza" -- Adj hozzá time.sleep(2) szünetet az API hívások közé, vagy implementálj exponenciális visszalépést (exponential backoff). A GPT-5.4 computer use munkamenetek elérhetik a sebességkorlátokat, ha túl gyorsan küldöd a screenshotokat.

"Magas token költségek" -- A teljes felbontású screenshotok sok tokent fogyasztanak. Csökkentsd a költségeket a screenshotok átméretezésével kódolás előtt:

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

Átméretezett screenshotok használatakor ne felejtsd el megszorozni a GPT-5.4 által visszaadott koordinátákat az arány inverzével, mielőtt átadnád őket a PyAutoGUI-nak.

"A GPT-5.4 ciklusba kerül" -- Ha a modell folyamatosan ugyanazt a műveletet ismétli, elképzelhető, hogy összezavarodott a UI állapotától. Adj hozzá logikát az ismétlődő műveletek észlelésére és a ciklus megszakítására, vagy növeld az érvelési erőfeszítést (reasoning effort) "high" szintre a jobb döntéshozatal érdekében.

---

Mi a következő lépés

Miután működik az alapvető automatizálási ciklusod, íme néhány módszer a kiterjesztésére:

Láncolj össze több feladatot. Építs fel egy munkafolyamatot, amely megnyitja az e-mailjeidet, letölt egy mellékletet, megnyitja azt egy táblázatkezelőben, kinyer belőle bizonyos cellákat, és beilleszti az értékeket egy jelentéssablonba. Minden lépés ugyanazt a screenshot-elemzés-művelet ciklust használja.

Adj hozzá hibahelyreállítást. Ellenőrizz minden screenshot-ot hibaüzenetek vagy váratlan állapotok után kutatva. Ha a GPT-5.4 észleli, hogy valami hiba történt, megpróbálhatja helyreállítani a folyamatot a "Mégse" gombra kattintva, az Escape billentyű megnyomásával vagy az utolsó művelet megismétlésével.

Kombináld a Playwright eszközzel böngészőfeladatokhoz. Kizárólag webes automatizáláshoz a GPT-5.4 Playwright kódot is tud írni a böngészőkkel való programozott interakcióhoz. Ez gyorsabb és megbízhatóbb, mint a screenshot-alapú kattintgatás strukturált weboldalak esetén. Használd a Computer Use-t asztali alkalmazásokhoz, a Playwright-ot pedig böngésző-automatizáláshoz.

Építs feladatkönyvtárat. Mentsd el a gyakori promptokat és munkafolyamatokat újrafelhasználható függvényekként. Hozz létre egy tasks/ könyvtárat olyan scriptekkel, mint a fill_invoice.py, export_report.py és update_crm.py, amelyeket a csapatod igény szerint futtathat.

Ütemezd az automatizálásokat. Használd a cron (Linux/macOS) vagy a Feladatütemező (Windows) eszközt az automatizálási scriptek meghatározott időpontokban történő futtatásához. Kombináld virtuális kijelzővel a teljes mértékben headless működéshez.

A GPT-5.4 Computer Use még új képesség, és az API felülete fejlődni fog. Tartsd frissen az openai csomagodat a pip install --upgrade openai paranccsal, hogy megkapd a legújabb eszköztípusokat és paramétereket, ahogy az OpenAI finomítja a funkciót.

Az ebben az útmutatóban szereplő kód egy működő alapot ad. Kezdd egyszerű, alacsony kockázatú feladatokkal, igazold, hogy az automatizálás megfelelően működik, majd skálázd fel komplexebb munkafolyamatokra, ahogy nő a bizalmad a rendszerben.