Ključne ugotovitve

• Zanka posnetek zaslona-dejanje je osrednji vzorec: Vaša skripta zajame posnetek zaslona, ga pošlje modelu GPT-5.4 prek Responses API z omogočeno funkcijo computer_use, prejme strukturirane ukaze za dejanja (klik, tipkanje, pomikanje) in jih izvede s PyAutoGUI v zanki.
• GPT-5.4 je premagal človeške strokovnjake na OSWorld s 75%: To je prvi AI model, ki je presegel človeško zmogljivost na merilih uspešnosti namizne avtomatizacije, kar omogoča izvedljivo praktično avtomatizacijo za resnične delovne procese.
• Strošek je presenetljivo nizek: Tipična seja avtomatizacije z 10-20 posnetki zaslona stane $0.10-0.50, obračunana po standardnih tarifah za GPT-5.4 (približno $10/$30 na milijon vhodnih/izhodnih tokens).
• Varnost zahteva, da vaša koda izvaja dejanja: GPT-5.4 pošilja le ukaze za dejanja — vaša aplikacija se odloči, ali jih bo izvedla, zato sta testiranje v peskovniku (sandboxed testing) in pregled dejanj bistvena pred zagonom brez nadzora.
• Trije predpogoji za začetek: Python 3.10+, OpenAI API ključ z dostopom Tier 1 (najmanj $5 predhodne porabe) in namizno okolje z zaslonom.

GPT-5.4 je na merilu OSWorld dosegel 75%, s čimer je prvič premagal človeške strokovnjake pri namizni avtomatizaciji. Vendar sta poznavanje rezultatov meril in dejanska uporaba Computer Use dve zelo različni stvari.

Ta vodič premošča to vrzel. Do konca boste imeli delujočo Python skripto, ki zajema posnetke vašega namizja, jih pošilja modelu GPT-5.4, prejema strukturirane ukaze za dejanja in jih samodejno izvaja. Brez teorije, brez oglaševanja — samo koda, ki jo lahko zaženete danes.

---

Kaj boste zgradili

Zgradili boste popolno zanko za namizno avtomatizacijo, ki deluje takole:

1. Vaša skripta zajame posnetek vašega zaslona.
2. Ta posnetek pošlje modelu GPT-5.4 prek OpenAI Responses API z omogočenim orodjem computer_use.
3. GPT-5.4 analizira posnetek zaslona in vrne strukturirana dejanja (klik, tipkanje, pomikanje, pritisk tipke).
4. Vaša skripta izvede ta dejanja z uporabo PyAutoGUI.
5. Zanka se ponavlja, dokler naloga ni opravljena.

Do konca tega vodiča boste imeli dva delujoča primera: enega, ki samodejno izpolni spletni obrazec, in enega, ki črpa podatke iz namizne aplikacije v datoteko CSV.

---

Predpogoji

Preden začnete, se prepričajte, da imate naslednje:

• Nameščen Python 3.10 ali novejši na vašem računalniku.
• OpenAI API ključ z dostopom do GPT-5.4 (zahteva plačljiv račun z vsaj Tier 1 dostopom — najmanj $5 predhodne porabe).
• Namizno okolje — Computer Use deluje na macOS, Windows in Linux z zaslonom. Za strežnike brez zaslona (headless) boste potrebovali virtualni zaslon, kot je Xvfb.
• Osnovno poznavanje jezika Python (ni vam treba biti strokovnjak — vsa koda je zagotovljena).

---

1. korak: Nastavitev okolja

Začnite z ustvarjanjem projektnega imenika in namestitvijo potrebnih paketov.

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

Kaj vsak paket počne:

• openai — Uradni OpenAI Python SDK za klicanje GPT-5.4 API.
• pyautogui — Večplatformska knjižnica za nadzor miške in tipkovnice.
• pillow — Knjižnica za obdelavo slik za upravljanje s posnetki zaslona.

Nato nastavite svoj API ključ kot okoljsko spremenljivko:

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

Na Windows namesto tega uporabite set OPENAI_API_KEY=sk-your-api-key-here.

Ustvarite datoteko z imenom automation.py in dodajte osnovno nastavitev:

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

Zaženite to, da preverite, ali je vse pravilno nameščeno:

python automation.py

Izpisati bi se morala vaša ločljivost zaslona. Če dobite napake pri uvozu, ponovno preverite, ali ste aktivirali virtualno okolje in namestili vse pakete.

---

2. korak: Zajem posnetka zaslona

Computer Use deluje tako, da analizira posnetke zaslona. Vaša koda zajame zaslon in ga pretvori v base64 kodiran niz, ki ga API lahko sprejme.

Dodajte to funkcijo v 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")

Preizkusite jo tako, da na dno datoteke dodate kratek preverjanje:

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

To bi moralo izpisati nekaj podobnega kot Screenshot captured: 2847392 characters (base64). Natančno število je odvisno od vaše ločljivosti zaslona in tega, kar je na zaslonu.

---

3. korak: Pošiljanje posnetka zaslona modelu GPT-5.4

Zdaj prihaja jedro Computer Use: pošiljanje posnetka zaslona modelu GPT-5.4 z omogočenim orodjem computer_use in prejemanje strukturiranih ukazov za dejanja v odgovoru.

Dodajte to funkcijo:

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

Razlaga ključnih parametrov:

• computer_use_preview — Pove modelu GPT-5.4, naj analizira posnetek zaslona in vrne namizna dejanja.
• display_width / display_height — Vaša ločljivost zaslona, da GPT-5.4 vrne koordinate, ki se ujemajo z vašim dejanskim zaslonom.
• environment — Nastavljeno na "mac", "windows" ali "linux", da GPT-5.4 uporablja pravilne bližnjice na tipkovnici in konvencije UI.
• reasoning.effort — Nadzoruje, koliko razmišljanja opravi GPT-5.4. Uporabite "medium" za standardne naloge, "high" za kompleksne večstopenjske delovne procese.
• previous_response_id — Poveže več klicov skupaj, tako da si GPT-5.4 zapomni, kaj je že storil.

---

4. korak: Izvajanje dejanj

GPT-5.4 v svojem odgovoru vrne strukturirane ukaze za dejanja. Te morate razčleniti in izvesti s PyAutoGUI.

Dodajte izvajalec dejanj:

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

To upravlja z vsemi vrstami dejanj, ki jih GPT-5.4 lahko vrne: klikanje, dvojno klikanje, tipkanje, pritiski tipk, pomikanje in vlečenje.

---

5. korak: Izgradnja zanke za avtomatizacijo

Zdaj vse povežite v celovito zanko za avtomatizacijo. To je glavni motor, ki izvaja vaše naloge:

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

Zdaj lahko zaženete katerokoli nalogo avtomatizacije z enim samim klicem funkcije:

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

To bo zajelo vaš zaslon, ga poslalo modelu GPT-5.4, GPT-5.4 pa bo ugotovil, kako odpreti Calculator in izvesti množenje — s klikanjem gumbov, branjem rezultata in zaustavitvijo, ko konča.

---

Praktični primer 1: Samodejno izpolnjevanje spletnega obrazca

Tukaj je celovit delujoč primer, ki izpolni spletni kontaktni obrazec. Shranite ga kot 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()

Kako ga uporabiti:

1. V brskalniku odprite spletno stran s kontaktnim obrazcem.
2. Prepričajte se, da je obrazec v celoti viden na zaslonu (pomikanje ni potrebno za prva polja).
3. Zaženite python autofill_form.py.
4. Opazujte, kako GPT-5.4 prepozna vsako polje, klikne nanj in vtipka pravilno vrednost.

---

Praktični primer 2: Črpanje podatkov iz namizne aplikacije

Ta primer bere podatke iz vidne preglednice ali tabelarične aplikacije in jih shrani v datoteko CSV. Shranite ga kot 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()

Kako ga uporabiti:

1. Odprite preglednico, pregledovalnik baz podatkov ali katerokoli aplikacijo s tabelaričnimi podatki, ki so vidni na zaslonu.
2. Zaženite python extract_data.py.
3. Preverite ustvarjeno datoteko extracted_data.csv za izločeno vsebino.

Za tabele, ki se raztezajo čez več strani, pokličite extract_multi_page_data(). Samodejno se bo pomikala navzdol in združila vse strani v eno datoteko CSV.

---

Najboljše prakse za varnost

Computer Use daje modelu GPT-5.4 možnost nadzora nad vašo miško in tipkovnico. Ta moč zahteva previdnost.

Vedno najprej uporabite peskovnik (sandbox). Preden zaženete katerokoli avtomatizacijo na svojem dejanskem namizju, jo preizkusite v virtualnem stroju ali Docker vsebniku z virtualnim zaslonom. To izolira napake in preprečuje nenamerno škodo.

Preglejte dejanja pred izvedbo. Spremenite funkcijo execute_action, da izpiše vsako dejanje in počaka na vašo potrditev pred izvedbo:

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

Nastavite omejitve hitrosti (rate limits). Dodajte največje število dejanj na sejo in proračun za stroške. Parameter max_steps v run_automation že omejuje število ponovitev zanke. Porabi tokens lahko sledite tudi prek objekta odgovora za spremljanje stroškov.

Nikoli ne avtomatizirajte občutljivih računov brez nadzora. Ne usmerjajte Computer Use na svojo bančno aplikacijo, e-pošto z občutljivimi podatki ali skrbniške konzole brez spremljanja vsakega dejanja. GPT-5.4 lahko napačno klikne, napačno prebere elemente uporabniškega vmesnika ali izbere nenamerne poti.

Uporabite varnostno zaustavitev (fail-safe) PyAutoGUI. Z pyautogui.FAILSAFE = True (kar je privzeto) lahko vsako avtomatizacijo prekinete tako, da miško hitro premaknete v zgornji levi kot zaslona. To imejte vedno omogočeno.

---

Odpravljanje pogostih težav

"Model ne vrne nobenih dejanj" -- Prepričajte se, da uporabljate computer_use_preview kot vrsto orodja, ne le computer_use. Preverite tudi, ali se display_width in display_height ujemata z vašo dejansko ločljivostjo zaslona. Če so vrednosti napačne, GPT-5.4 morda ne bo mogel pravilno interpretirati posnetka zaslona.

"Kliki pristanejo na napačnem mestu" -- To se običajno zgodi na zaslonih s skaliranjem (npr. Retina zasloni na macOS). PyAutoGUI deluje v slikovnih koordinatah (pixels), vaš zaslon pa morda uporablja logične koordinate. Poskusite zajeti ločljivost s pyautogui.size() in jo primerjajte s svojo dejansko ločljivostjo v pikslih. Na macOS z Retina zaslonom boste morda morali koordinate deliti s faktorjem skaliranja.

"PyAutoGUI ne najde zaslona" -- Na strežnikih Linux brez zaslona namestite in zaženite Xvfb: Xvfb :99 -screen 0 1920x1080x24 & nato export DISPLAY=:99. Na macOS morate Terminalu (ali vašemu IDE) podeliti dovoljenja za dostopnost v System Settings > Privacy & Security > Accessibility.

"API vrne napako 429 rate limit" -- Dodajte time.sleep(2) med klici API ali implementirajte eksponentno upočasnjevanje (exponential backoff). Seje GPT-5.4 computer use lahko dosežejo omejitve hitrosti, če posnetke zaslona pošiljate prehitro.

"Visoki stroški žetonov (tokens)" -- Posnetki zaslona v polni ločljivosti porabijo veliko tokens. Stroške zmanjšajte s spremembo velikosti posnetkov pred kodiranjem:

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

Pri uporabi posnetkov s spremenjeno velikostjo ne pozabite pomnožiti vrnjenih koordinat GPT-5.4 z inverznim razmerjem, preden jih posredujete PyAutoGUI.

"GPT-5.4 se zatakne v zanki" -- Če model nenehno ponavlja isto dejanje, ga morda zmede stanje UI. Dodajte logiko za zaznavanje ponavljajočih se dejanj in prekinitev zanke ali povečajte napor razmišljanja na "high" za boljše odločanje.

---

Kaj sledi

Ko imate osnovno zanko za avtomatizacijo delujočo, so tukaj načini za njeno razširitev:

Povežite več nalog. Zgradite delovni proces, ki odpre vašo e-pošto, prenese prilogo, jo odpre v preglednici, izloči določene celice in prilepi vrednosti v predlogo poročila. Vsak korak uporablja isto zanko posnetek-analiza-dejanje.

Dodajte odpravljanje napak. Preverite vsak posnetek zaslona za pogovorna okna z napakami ali nepričakovana stanja. Če GPT-5.4 zazna, da je šlo nekaj narobe, lahko poskusi s popravkom tako, da klikne "Prekliči", pritisne Escape ali ponovi zadnje dejanje.

Kombinirajte s Playwright za spletne naloge. Za avtomatizacijo, ki poteka samo v spletu, lahko GPT-5.4 piše tudi Playwright kodo za programsko interakcijo z brskalniki. To je hitrejše in zanesljivejše od klikanja na podlagi posnetkov zaslona za strukturirane spletne strani. Uporabite Computer Use za namizne aplikacije in Playwright za spletno avtomatizacijo.

Zgradite knjižnico nalog. Shranite pogoste pozive (prompts) in delovne procese kot funkcije za večkratno uporabo. Ustvarite imenik tasks/ s skriptami, kot so fill_invoice.py, export_report.py in update_crm.py, ki jih vaša ekipa lahko zažene po potrebi.

Načrtujte avtomatizacije. Uporabite cron (Linux/macOS) ali Task Scheduler (Windows) za zagon vaših skript za avtomatizacijo ob določenih časih. Kombinirajte z virtualnim zaslonom za popolno delovanje brez zaslona.

GPT-5.4 Computer Use je še vedno nova zmogljivost in API se bo razvijal. Svoj paket openai posodabljajte s pip install --upgrade openai, da dobite najnovejše vrste orodij in parametre, ko OpenAI izboljšuje funkcijo.

Koda v tem vodiču vam daje delujočo osnovo. Začnite s preprostimi nalogami z nizkim tveganjem, potrdite, da avtomatizacija deluje pravilno, nato pa povečajte obseg na bolj zapletene delovne procese, ko pridobite zaupanje v sistem.