Kluczowe wnioski

• Pętla zrzut ekranu-akcja jest głównym wzorcem: Twój skrypt wykonuje zrzut ekranu, wysyła go do GPT-5.4 za pośrednictwem API Responses z włączoną funkcją computer_use, otrzymuje ustrukturyzowane polecenia akcji (kliknięcie, wpisanie, przewinięcie) i wykonuje je za pomocą PyAutoGUI w pętli.
• GPT-5.4 pokonał ludzkich ekspertów w OSWorld z wynikiem 75%: Jest to pierwszy model AI, który przewyższył ludzką wydajność w testach porównawczych automatyzacji pulpitu, co sprawia, że praktyczna automatyzacja staje się realna dla rzeczywistych przepływów pracy.
• Koszt jest zaskakująco niski: Typowa sesja automatyzacji z 10-20 zrzutami ekranu kosztuje 0.10-0.50 USD, rozliczane według standardowych stawek GPT-5.4 (~10 USD/30 USD za milion input/output tokens).
• Bezpieczeństwo wymaga, aby Twój kod wykonywał akcje: GPT-5.4 wysyła tylko polecenia akcji — Twoja aplikacja decyduje, czy je wykonać, co sprawia, że testowanie w piaskownicy (sandbox) i przegląd akcji są niezbędne przed uruchomieniem bez nadzoru.
• Trzy wymagania wstępne, aby zacząć: Python 3.10+, klucz API OpenAI z dostępem Tier 1 (minimum 5 USD wcześniejszych wydatków) oraz środowisko desktopowe z wyświetlaczem.

GPT-5.4 uzyskał wynik 75% w benchmarku OSWorld, po raz pierwszy pokonując ludzkich ekspertów w automatyzacji pulpitu. Jednak znajomość wyników testów a faktyczne korzystanie z Computer Use to dwie zupełnie inne rzeczy.

Ten przewodnik wypełnia tę lukę. Pod koniec będziesz mieć działający skrypt Python, który wykonuje zrzuty ekranu Twojego pulpitu, wysyła je do GPT-5.4, odbiera ustrukturyzowane polecenia akcji i wykonuje je automatycznie. Bez teorii, bez szumu — tylko kod, który możesz uruchomić już dziś.

---

Co zbudujesz

Zbudujesz kompletną pętlę automatyzacji pulpitu, która działa w następujący sposób:

1. Twój skrypt wykonuje zrzut ekranu Twojego wyświetlacza.
2. Wysyła ten zrzut ekranu do GPT-5.4 przez OpenAI API Responses z włączonym narzędziem computer_use.
3. GPT-5.4 analizuje zrzut ekranu i zwraca ustrukturyzowane akcje (kliknięcie, wpisywanie, przewijanie, naciśnięcie klawisza).
4. Twój skrypt wykonuje te akcje za pomocą PyAutoGUI.
5. Pętla powtarza się aż do zakończenia zadania.

Pod koniec tego samouczka będziesz mieć dwa działające przykłady: jeden, który automatycznie wypełnia formularz internetowy, oraz drugi, który wyodrębnia dane z aplikacji desktopowej do pliku CSV.

---

Wymagania wstępne

Zanim zaczniesz, upewnij się, że posiadasz:

• Python 3.10 lub nowszy zainstalowany na Twoim komputerze.
• Klucz API OpenAI z dostępem do GPT-5.4 (wymaga płatnego konta z dostępem co najmniej Tier 1 — minimum 5 USD wcześniejszych wydatków).
• Środowisko desktopowe — Computer Use działa na macOS, Windows i Linux z wyświetlaczem. W przypadku serwerów bezgłowych (headless) potrzebny będzie wirtualny wyświetlacz, taki jak Xvfb.
• Podstawowa znajomość Python (nie musisz być ekspertem — cały kod jest dostarczony).

---

Krok 1: Skonfiguruj swoje środowisko

Zacznij od utworzenia katalogu projektu i zainstalowania wymaganych pakietów.

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

Za co odpowiada każdy pakiet:

• openai — Oficjalny Python SDK OpenAI do wywoływania API GPT-5.4.
• pyautogui — Wieloplatformowa biblioteka do sterowania myszą i klawiaturą.
• pillow — Biblioteka do przetwarzania obrazów do obsługi zrzutów ekranu.

Następnie ustaw swój klucz API jako zmienną środowiskową:

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

W systemie Windows użyj polecenia set OPENAI_API_KEY=sk-your-api-key-here.

Utwórz plik o nazwie automation.py i dodaj podstawową konfigurację:

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

Uruchom to, aby sprawdzić, czy wszystko jest zainstalowane poprawnie:

python automation.py

Powinieneś zobaczyć wydrukowaną rozdzielczość ekranu. Jeśli wystąpią błędy importu, sprawdź dwukrotnie, czy aktywowałeś środowisko wirtualne i zainstalowałeś wszystkie pakiety.

---

Krok 2: Zrób zrzut ekranu

Computer Use działa poprzez analizę zrzutów ekranu. Twój kod przechwytuje ekran i konwertuje go na ciąg znaków zakodowany w base64, który API może zaakceptować.

Dodaj tę funkcję do 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")

Przetestuj to, dodając szybkie sprawdzenie na dole pliku:

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

Powinno to wydrukować coś w stylu Screenshot captured: 2847392 characters (base64). Dokładna liczba zależy od rozdzielczości ekranu i tego, co znajduje się na ekranie.

---

Krok 3: Wyślij zrzut ekranu do GPT-5.4

Teraz przechodzimy do sedna Computer Use: wysyłania zrzutu ekranu do GPT-5.4 z włączonym narzędziem computer_use i otrzymywania w zamian ustrukturyzowanych poleceń akcji.

Dodaj tę funkcję:

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

Objaśnienie kluczowych parametrów:

• computer_use_preview — Mówi GPT-5.4, aby przeanalizował zrzut ekranu i zwrócił akcje pulpitu.
• display_width / display_height — Twoja rozdzielczość ekranu, aby GPT-5.4 zwracał współrzędne pasujące do Twojego rzeczywistego wyświetlacza.
• environment — Ustaw na "mac", "windows" lub "linux", aby GPT-5.4 używał właściwych skrótów klawiszowych i konwencji UI.
• reasoning.effort — Kontroluje, jak intensywnie GPT-5.4 ma rozumować. Użyj "medium" dla standardowych zadań, "high" dla złożonych, wieloetapowych procesów.
• previous_response_id — Łączy wiele wywołań, dzięki czemu GPT-5.4 pamięta, co już zrobił.

---

Krok 4: Wykonaj akcje

GPT-5.4 zwraca w odpowiedzi ustrukturyzowane polecenia akcji. Musisz je sparsować i wykonać za pomocą PyAutoGUI.

Dodaj moduł wykonujący akcje:

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

Obsługuje to wszystkie typy akcji, które może zwrócić GPT-5.4: klikanie, podwójne klikanie, pisanie, naciśnięcia klawiszy, przewijanie i przeciąganie.

---

Krok 5: Zbuduj pętlę automatyzacji

Teraz połącz wszystko w kompletną pętlę automatyzacji. Jest to główny silnik, który uruchamia Twoje zadania:

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

Możesz teraz uruchomić dowolne zadanie automatyzacji za pomocą jednego wywołania funkcji:

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

Spowoduje to przechwycenie ekranu, wysłanie go do GPT-5.4, a GPT-5.4 wymyśli, jak otworzyć Kalkulator i wykonać mnożenie — klikając przyciski, odczytując wynik i zatrzymując się po zakończeniu.

---

Praktyczny przykład 1: Automatyczne wypełnianie formularza internetowego

Oto kompletny, działający przykład wypełniający formularz kontaktowy online. Zapisz to jako 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()

Jak tego użyć:

1. Otwórz w przeglądarce stronę internetową z formularzem kontaktowym.
2. Upewnij się, że formularz jest w pełni widoczny na ekranie (bez konieczności przewijania dla pierwszych pól).
3. Uruchom python autofill_form.py.
4. Obserwuj, jak GPT-5.4 identyfikuje każde pole, klika je i wpisuje poprawną wartość.

---

Praktyczny przykład 2: Wyodrębnianie danych z aplikacji desktopowej

Ten przykład odczytuje dane z widocznego arkusza kalkulacyjnego lub tabeli w aplikacji i zapisuje je w pliku CSV. Zapisz to jako 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()

Jak tego użyć:

1. Otwórz arkusz kalkulacyjny, przeglądarkę bazy danych lub dowolną aplikację z danymi tabelarycznymi widocznymi na ekranie.
2. Uruchom python extract_data.py.
3. Sprawdź wygenerowany plik extracted_data.csv pod kątem wyodrębnionej zawartości.

W przypadku tabel obejmujących wiele stron wywołaj zamiast tego extract_multi_page_data(). Skrypt automatycznie przewinie i połączy wszystkie strony w jeden plik CSV.

---

Najlepsze praktyki bezpieczeństwa

Computer Use daje GPT-5.4 możliwość sterowania Twoją myszą i klawiaturą. Ta moc wymaga ostrożności.

Zawsze najpierw testuj w piaskownicy. Zanim uruchomisz jakąkolwiek automatyzację na swoim rzeczywistym pulpicie, przetestuj ją w maszynie wirtualnej lub kontenerze Docker z wirtualnym wyświetlaczem. Izoluje to błędy i zapobiega przypadkowym uszkodzeniom.

Przeglądaj akcje przed wykonaniem. Zmodyfikuj funkcję execute_action, aby drukowała każdą akcję i czekała na Twoje potwierdzenie przed wykonaniem:

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

Ustaw limity stawek. Dodaj maksymalną liczbę akcji na sesję i maksymalny budżet kosztów. Parametr max_steps w run_automation już ogranicza liczbę powtórzeń pętli. Możesz także śledzić zużycie tokenów z obiektu odpowiedzi, aby monitorować koszty.

Nigdy nie automatyzuj wrażliwych kont bez nadzoru. Nie kieruj Computer Use na swoją aplikację bankową, e-maile z wrażliwymi danymi ani konsole administracyjne bez obserwowania każdej akcji. GPT-5.4 może źle kliknąć, błędnie odczytać elementy interfejsu lub obrać niezamierzone ścieżki.

Używaj mechanizmu fail-safe PyAutoGUI. Dzięki pyautogui.FAILSAFE = True (co jest ustawieniem domyślnym), możesz przerwać każdą automatyzację, szybko przesuwając mysz w lewy górny róg ekranu. Miej to włączone przez cały czas.

---

Rozwiązywanie typowych problemów

"Model nie zwraca żadnych akcji" — Upewnij się, że używasz computer_use_preview jako typu narzędzia, a nie tylko computer_use. Sprawdź również, czy display_width i display_height pasują do Twojej rzeczywistej rozdzielczości ekranu. Jeśli wartości są błędne, GPT-5.4 może nie być w stanie poprawnie zinterpretować zrzutu ekranu.

"Kliknięcia lądują w złej pozycji" — Zazwyczaj dzieje się to na wyświetlaczach ze skalowaniem (np. wyświetlacze Retina na macOS). PyAutoGUI działa we współrzędnych pikselowych, ale Twój wyświetlacz może używać współrzędnych logicznych. Spróbuj pobrać rozdzielczość za pomocą pyautogui.size() i porównaj ją z rzeczywistą rozdzielczością pikselową. Na macOS z Retina może być konieczne podzielenie współrzędnych przez współczynnik skalowania.

"PyAutoGUI nie może znaleźć wyświetlacza" — Na serwerach Linux bez interfejsu graficznego zainstaluj i uruchom Xvfb: Xvfb :99 -screen 0 1920x1080x24 &, a następnie export DISPLAY=:99. Na macOS musisz przyznać Terminalowi (lub Twojemu IDE) uprawnienia dostępności w Ustawienia systemowe > Prywatność i bezpieczeństwo > Dostępność.

"API zwraca błąd 429 rate limit" — Dodaj time.sleep(2) między wywołaniami API lub zaimplementuj wykładniczy czas oczekiwania (exponential backoff). Sesje Computer Use GPT-5.4 mogą uderzać w limity częstotliwości, jeśli zrzuty ekranu są wysyłane zbyt szybko.

"Wysokie koszty tokenów" — Zrzuty ekranu w pełnej rozdzielczości zużywają dużo tokenów. Zmniejsz koszty, zmieniając rozmiar zrzutów przed ich zakodowaniem:

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

Używając zrzutów o zmienionym rozmiarze, pamiętaj o pomnożeniu współrzędnych zwróconych przez GPT-5.4 przez odwrotność proporcji przed przekazaniem ich do PyAutoGUI.

"GPT-5.4 utknął w pętli" — Jeśli model powtarza tę samą akcję, może być zdezorientowany stanem interfejsu użytkownika. Dodaj logikę wykrywającą powtarzające się akcje i przerywającą pętlę lub zwiększ wysiłek rozumowania na "high" dla lepszego podejmowania decyzji.

---

Co dalej

Gdy podstawowa pętla automatyzacji już działa, oto sposoby na jej rozszerzenie:

Łączenie wielu zadań w łańcuch. Zbuduj przepływ pracy, który otwiera Twój e-mail, pobiera załącznik, otwiera go w arkuszu kalkulacyjnym, wyodrębnia określone komórki i wkleja wartości do szablonu raportu. Każdy krok wykorzystuje tę samą pętlę zrzut ekranu-analiza-akcja.

Dodawanie odzyskiwania po błędach. Sprawdzaj każdy zrzut ekranu pod kątem okien dialogowych z błędami lub nieoczekiwanych stanów. Jeśli GPT-5.4 wykryje, że coś poszło nie tak, może spróbować naprawić sytuację, klikając "Anuluj", naciskając Escape lub ponawiając ostatnią akcję.

Połączenie z Playwright dla zadań w przeglądarce. W przypadku automatyzacji wyłącznie internetowej GPT-5.4 może również pisać kod Playwright do interakcji z przeglądarkami w sposób programowy. Jest to szybsze i bardziej niezawodne niż klikanie oparte na zrzutach ekranu w przypadku ustrukturyzowanych stron internetowych. Używaj Computer Use dla aplikacji desktopowych, a Playwright do automatyzacji przeglądarki.

Budowanie biblioteki zadań. Zapisuj popularne prompty i przepływy pracy jako funkcje wielokrotnego użytku. Utwórz katalog tasks/ ze skryptami takimi jak fill_invoice.py, export_report.py i update_crm.py, które Twój zespół może uruchamiać na żądanie.

Harmonogramowanie automatyzacji. Użyj cron (Linux/macOS) lub Harmonogramu zadań (Windows), aby uruchamiać skrypty automatyzacji o określonych godzinach. Połącz to z wirtualnym wyświetlaczem dla w pełni bezobsługowej pracy.

GPT-5.4 Computer Use to wciąż nowa funkcja, a API będzie ewoluować. Aktualizuj swój pakiet openai za pomocą pip install --upgrade openai, aby otrzymywać najnowsze typy narzędzi i parametry w miarę dopracowywania tej funkcji przez OpenAI.

Kod w tym samouczku daje Ci działający fundament. Zacznij od prostych zadań o niskim ryzyku, sprawdź, czy automatyzacja działa poprawnie, a następnie skaluj ją do bardziej złożonych procesów w miarę budowania zaufania do systemu.