Klíčové poznatky

• Smyčka screenshot-akce je základním vzorcem: Váš skript pořídí screenshot, odešle jej do GPT-5.4 prostřednictvím Responses API se zapnutou funkcí computer_use, přijme strukturované příkazy k akci (kliknutí, psaní, rolování) a provede je pomocí PyAutoGUI ve smyčce.
• GPT-5.4 překonal lidské experty v OSWorld se skóre 75 %: Toto je první AI model, který překonal lidský výkon v benchmarku automatizace desktopu, díky čemuž je praktická automatizace reálných pracovních postupů proveditelná.
• Náklady jsou překvapivě nízké: Typická automatizační relace s 10-20 screenshoty stojí 0.10-0.50 $, účtováno podle standardních sazeb GPT-5.4 (přibližně 10 $/30 $ za milion vstupních/výstupních tokens).
• Bezpečnost vyžaduje, aby akce prováděl váš kód: GPT-5.4 pouze posílá příkazy k akci — vaše aplikace rozhoduje, zda je provede, což činí testování v sandboxu a kontrolu akcí nezbytnými před spuštěním bez dozoru.
• Tři předpoklady pro začátek: Python 3.10+, OpenAI API klíč s přístupem Tier 1 (minimální předchozí útrata 5 $) a desktopové prostředí s displejem.

GPT-5.4 dosáhl v benchmarku OSWorld skóre 75 %, čímž poprvé překonal lidské experty v automatizaci desktopu. Ale znát výsledky benchmarku a skutečně Computer Use používat jsou dvě velmi odlišné věci.

Tato příručka tuto mezeru překlenuje. Na konci budete mít funkční Python skript, který pořizuje screenshoty vaší plochy, odesílá je do GPT-5.4, přijímá strukturované příkazy k akcím a automaticky je provádí. Žádná teorie, žádný hype — jen kód, který můžete spustit ještě dnes.

---

Co vytvoříte

Sestavíte kompletní smyčku automatizace desktopu, která funguje následovně:

1. Váš skript pořídí screenshot vaší obrazovky.
2. Odešle tento screenshot do GPT-5.4 přes OpenAI Responses API se zapnutým nástrojem computer_use.
3. GPT-5.4 analyzuje screenshot a vrátí strukturované akce (kliknutí, psaní, rolování, stisk klávesy).
4. Váš skript tyto akce provede pomocí PyAutoGUI.
5. Smyčka se opakuje, dokud není úkol dokončen.

Na konci tohoto tutoriálu budete mít dva funkční příklady: jeden, který automaticky vyplní webový formulář, a druhý, který extrahuje data z desktopové aplikace do CSV souboru.

---

Předpoklady

Než začnete, ujistěte se, že máte následující:

• Python 3.10 nebo novější nainstalovaný ve vašem počítači.
• OpenAI API klíč s přístupem k GPT-5.4 (vyžaduje placený účet s minimálně Tier 1 přístupem — minimální předchozí útrata 5 $).
• Desktopové prostředí — Computer Use funguje na macOS, Windows a Linux s displejem. Pro headless servery budete potřebovat virtuální displej jako Xvfb.
• Základní znalost Python (nemusíte být expert — veškerý kód je k dispozici).

---

Krok 1: Nastavení prostředí

Začněte vytvořením adresáře projektu a instalací požadovaných balíčků.

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

Co každý balíček dělá:

• openai — Oficiální OpenAI Python SDK pro volání GPT-5.4 API.
• pyautogui — Multiplatformní knihovna pro ovládání myši a klávesnice.
• pillow — Knihovna pro zpracování obrazu pro manipulaci se screenshoty.

Dále nastavte svůj API klíč jako proměnnou prostředí:

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

Na Windows použijte místo toho set OPENAI_API_KEY=sk-your-api-key-here.

Vytvořte soubor s názvem automation.py a přidejte základní nastavení:

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

Spusťte toto pro ověření, že je vše správně nainstalováno:

python automation.py

Měli byste vidět vypsané rozlišení vaší obrazovky. Pokud narazíte na chyby při importu, znovu zkontrolujte, zda jste aktivovali virtuální prostředí a nainstalovali všechny balíčky.

---

Krok 2: Pořízení screenshotu

Computer Use funguje na základě analýzy screenshotů. Váš kód zachytí obrazovku a převede ji na řetězec kódovaný v base64, který API dokáže přijmout.

Přidejte tuto funkci 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")

Otestujte ji přidáním rychlé kontroly na konec souboru:

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

To by mělo vypsat něco jako Screenshot captured: 2847392 characters (base64). Přesné číslo závisí na rozlišení vaší obrazovky a na tom, co je na ní zobrazeno.

---

Krok 3: Odeslání screenshotu do GPT-5.4

Nyní přichází jádro Computer Use: odeslání screenshotu do GPT-5.4 se zapnutým nástrojem computer_use a přijetí strukturovaných příkazů k akci v odpovědi.

Přidejte tuto funkci:

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

Vysvětlení klíčových parametrů:

• computer_use_preview — Říká GPT-5.4, aby analyzoval screenshot a vrátil akce na ploše.
• display_width / display_height — Rozlišení vaší obrazovky, aby GPT-5.4 vracel souřadnice, které odpovídají vašemu skutečnému displeji.
• environment — Nastavte na "mac", "windows" nebo "linux", aby GPT-5.4 používal správné klávesové zkratky a konvence uživatelského rozhraní.
• reasoning.effort — Ovládá, kolik uvažování GPT-5.4 provádí. Použijte "medium" pro standardní úkoly, "high" pro složité vícestupňové pracovní postupy.
• previous_response_id — Řetězí více volání dohromady, takže si GPT-5.4 pamatuje, co již udělal.

---

Krok 4: Provádění akcí

GPT-5.4 vrací ve své odpovědi strukturované příkazy k akci. Tyto příkazy musíte naparsovat a provést pomocí PyAutoGUI.

Přidejte vykonavatel akcí:

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

Toto zpracovává všechny typy akcí, které může GPT-5.4 vrátit: klikání, dvojité kliknutí, psaní, stisky kláves, rolování a přetahování.

---

Krok 5: Sestavení automatizační smyčky

Nyní vše propojte do kompletní automatizační smyčky. Toto je hlavní motor, který pohání vaše úkoly:

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

Nyní můžete spustit jakýkoli automatizační úkol jediným voláním funkce:

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

To zachytí vaši obrazovku, odešle ji do GPT-5.4 a GPT-5.4 zjistí, jak otevřít kalkulačku a provést násobení — klikáním na tlačítka, přečtením výsledku a zastavením po dokončení.

---

Praktický příklad 1: Automatické vyplnění webového formuláře

Zde je kompletní funkční příklad, který vyplní webový kontaktní formulář. Uložte jej 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 jej použít:

1. Otevřete ve svém prohlížeči webovou stránku s kontaktním formulářem.
2. Ujistěte se, že je formulář na obrazovce plně viditelný (pro první pole není potřeba rolovat).
3. Spusťte python autofill_form.py.
4. Sledujte, jak GPT-5.4 identifikuje každé pole, klikne do něj a napíše správnou hodnotu.

---

Praktický příklad 2: Extrakce dat z desktopové aplikace

Tento příklad čte data z viditelného tabulkového procesoru nebo aplikace s tabulkou a ukládá je do CSV souboru. Uložte jej 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 jej použít:

1. Otevřete tabulkový procesor, prohlížeč databáze nebo jakoukoli aplikaci s tabulkovými daty viditelnými na obrazovce.
2. Spusťte python extract_data.py.
3. Zkontrolujte vygenerovaný soubor extracted_data.csv s extrahovaným obsahem.

U tabulek, které se rozkládají na více stránek, zavolejte místo toho extract_multi_page_data(). Automaticky odroluje a spojí všechny stránky do jednoho CSV.

---

Osvědčené postupy pro bezpečnost

Computer Use dává GPT-5.4 schopnost ovládat vaši myš a klávesnici. Tato síla vyžaduje opatrnost.

Vždy nejprve v sandboxu. Před spuštěním jakékoli automatizace na vašem skutečném desktopu ji otestujte ve virtuálním stroji nebo v Docker kontejneru s virtuálním displejem. To izoluje chyby a zabrání náhodnému poškození.

Před provedením akce zkontrolujte. Upravte funkci execute_action tak, aby vypsala každou akci a před jejím provedením počkala na vaše potvrzení:

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

Nastavte limity požadavků. Přidejte maximální počet akcí na relaci a maximální rozpočet nákladů. Parametr max_steps v run_automation již limituje počet opakování smyčky. Můžete také sledovat využití tokens z objektu odpovědi a hlídat tak náklady.

Nikdy neautomatizujte citlivé účty bez dozoru. Nepoužívejte Computer Use na svou bankovní aplikaci, e-maily s citlivými daty nebo administrátorské konzole, aniž byste sledovali každou akci. GPT-5.4 může kliknout vedle, špatně přečíst prvky uživatelského rozhraní nebo se vydat nechtěnou cestou.

Používejte fail-safe funkci PyAutoGUI. S nastavením pyautogui.FAILSAFE = True (což je výchozí hodnota) můžete jakoukoli automatizaci přerušit rychlým přesunutím myši do levého horního rohu obrazovky. Tuto funkci mějte neustále zapnutou.

---

Řešení běžných problémů

"Model nevrací žádné akce" -- Ujistěte se, že jako typ nástroje používáte computer_use_preview, nikoli jen computer_use. Také ověřte, že vaše display_width a display_height odpovídají skutečnému rozlišení vaší obrazovky. Pokud jsou hodnoty špatně, GPT-5.4 nemusí být schopen správně interpretovat screenshot.

"Kliknutí dopadají na špatné místo" -- To se obvykle stává na displejích se škálováním (např. Retina displeje na macOS). PyAutoGUI pracuje v souřadnicích pixelů, ale váš displej může používat logické souřadnice. Zkuste zjistit své rozlišení pomocí pyautogui.size() a porovnejte ho se svým skutečným rozlišením v pixelech. Na macOS s Retina displejem možná budete muset souřadnice vydělit faktorem škálování.

"PyAutoGUI nemůže najít displej" -- Na headless Linux serverech nainstalujte a spusťte Xvfb: Xvfb :99 -screen 0 1920x1080x24 & a poté export DISPLAY=:99. Na macOS musíte Terminalu (nebo svému IDE) udělit oprávnění k přístupnosti v System Settings > Privacy & Security > Accessibility.

"API vrací chybu rate limitu 429" -- Přidejte time.sleep(2) mezi volání API nebo implementujte exponenciální odkládání (exponential backoff). Relace GPT-5.4 Computer Use mohou narazit na limity požadavků, pokud posíláte screenshoty příliš rychle.

"Vysoké náklady na tokens" -- Screenshoty v plném rozlišení spotřebovávají mnoho tokens. Snižte náklady změnou velikosti screenshotů před jejich kódováním:

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

Při použití zmenšených screenshotů nezapomeňte vynásobit souřadnice vrácené GPT-5.4 převrácenou hodnotou poměru (ratio) předtím, než je předáte do PyAutoGUI.

"GPT-5.4 uvízl ve smyčce" -- Pokud model neustále opakuje stejnou akci, může být zmaten stavem uživatelského rozhraní. Přidejte logiku pro detekci opakovaných akcí a přerušení smyčky, nebo zvyšte úsilí uvažování (reasoning effort) na "high" pro lepší rozhodování.

---

Co dál

Jakmile vám základní automatizační smyčka funguje, zde jsou způsoby, jak ji rozšířit:

Řetězení více úkolů. Sestavte pracovní postup, který otevře váš e-mail, stáhne přílohu, otevře ji v tabulkovém procesoru, extrahuje konkrétní buňky a vloží hodnoty do šablony zprávy. Každý krok využívá stejnou smyčku screenshot-analýza-akce.

Přidání zotavení po chybě. Kontrolujte každý screenshot, zda neobsahuje chybové dialogy nebo neočekávané stavy. Pokud GPT-5.4 zjistí, že se něco pokazilo, může se pokusit o nápravu kliknutím na "Zrušit", stisknutím klávesy Escape nebo opakováním poslední akce.

Kombinace s Playwright pro webové úkoly. Pro automatizaci čistě webových úkolů může GPT-5.4 také psát Playwright kód pro programovou interakci s prohlížeči. To je rychlejší a spolehlivější než klikání založené na screenshotech u strukturovaných webových stránek. Používejte Computer Use pro desktopové aplikace a Playwright pro automatizaci prohlížeče.

Vytvoření knihovny úkolů. Ukládejte běžné prompty a pracovní postupy jako znovupoužitelné funkce. Vytvořte adresář tasks/ se skripty jako fill_invoice.py, export_report.py a update_crm.py, které může váš tým spouštět podle potřeby.

Plánování automatizací. Použijte cron (Linux/macOS) nebo Task Scheduler (Windows) ke spouštění svých automatizačních skriptů v nastavený čas. Zkombinujte s virtuálním displejem pro plně headless provoz.

GPT-5.4 Computer Use je stále nová funkce a rozhraní API se bude vyvíjet. Udržujte svůj balíček openai aktualizovaný pomocí pip install --upgrade openai, abyste získali nejnovější typy nástrojů a parametrů, jak OpenAI tuto funkci vylepšuje.

Kód v tomto tutoriálu vám poskytuje funkční základ. Začněte s jednoduchými, nízkorizikovými úkoly, ověřte, že automatizace funguje správně, a poté přejděte ke složitějším pracovním postupům, jakmile získáte důvěru v systém.