Idei principale

• Bucla screenshot-acțiune este modelul de bază: Scriptul tău capturează un screenshot, îl trimite către GPT-5.4 prin Responses API cu computer_use activat, primește comenzi de acțiune structurate (click, type, scroll) și le execută cu PyAutoGUI într-o buclă.
• GPT-5.4 a învins experții umani pe OSWorld la 75%: Acesta este primul model AI care depășește performanța umană în benchmark-urile de automatizare a desktopului, făcând automatizarea practică viabilă pentru fluxuri de lucru reale.
• Costul este surprinzător de mic: O sesiune tipică de automatizare cu 10-20 de screenshot-uri costă $0.10-0.50, taxată la tarifele standard ale GPT-5.4 (~$10/$30 per milion de input/output tokens).
• Siguranța necesită ca codul tău să execute acțiunile: GPT-5.4 trimite doar comenzi de acțiune -- aplicația ta decide dacă le execută, făcând testarea în sandbox și revizuirea acțiunilor esențiale înainte de rularea nesupravegheată.
• Trei condiții prealabile pentru a începe: Python 3.10+, o cheie API OpenAI cu acces Tier 1 (cheltuieli anterioare de minimum $5) și un mediu desktop cu ecran.

GPT-5.4 a obținut 75% în benchmark-ul OSWorld, învingând experții umani la automatizarea desktopului pentru prima dată. Dar cunoașterea rezultatelor benchmark-ului și utilizarea efectivă a Computer Use de către tine sunt două lucruri foarte diferite.

Acest ghid face legătura între ele. Până la final, vei avea un script Python funcțional care face screenshot-uri ale desktopului tău, le trimite către GPT-5.4, primește comenzi de acțiune structurate și le execută automat. Fără teorie, fără entuziasm exagerat — doar cod pe care îl poți rula astăzi.

---

Ce vei construi

Vei construi o buclă completă de automatizare a desktopului care funcționează astfel:

1. Scriptul tău capturează un screenshot al ecranului tău
2. Trimite acel screenshot către GPT-5.4 prin OpenAI Responses API cu instrumentul computer_use activat
3. GPT-5.4 analizează screenshot-ul și returnează acțiuni structurate (click, type, scroll, keypress)
4. Scriptul tău execută acele acțiuni folosind PyAutoGUI
5. Bucla se repetă până când sarcina este finalizată

Până la sfârșitul acestui tutorial, vei avea două exemple funcționale: unul care completează automat un formular web și unul care extrage date dintr-o aplicație desktop într-un fișier CSV.

---

Condiții prealabile

Înainte de a începe, asigură-te că ai următoarele:

• Python 3.10 sau ulterior instalat pe mașina ta
• O cheie API OpenAI cu acces la GPT-5.4 (necesită un cont plătit cu cel puțin acces Tier 1 — minimum $5 cheltuiți anterior)
• Un mediu desktop — Computer Use funcționează pe macOS, Windows și Linux cu un afișaj. Pentru servere headless, vei avea nevoie de un afișaj virtual precum Xvfb
• Familiaritate de bază cu Python (nu trebuie să fii expert — tot codul este furnizat)

---

Pasul 1: Configurează-ți mediul

Începe prin a crea un director de proiect și a instala pachetele necesare.

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

Ce face fiecare pachet:

• openai — SDK-ul oficial OpenAI Python pentru apelarea API-ului GPT-5.4
• pyautogui — Bibliotecă multi-platformă pentru controlul mouse-ului și al tastaturii
• pillow — Bibliotecă de procesare a imaginilor pentru gestionarea screenshot-urilor

Apoi, setează cheia API ca variabilă de mediu:

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

Pe Windows, folosește set OPENAI_API_KEY=sk-your-api-key-here în schimb.

Creează un fișier numit automation.py și adaugă configurarea de bază:

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

Rulează acest cod pentru a verifica dacă totul este instalat corect:

python automation.py

Ar trebui să vezi rezoluția ecranului tău afișată. Dacă primești erori de import, verifică din nou dacă ai activat mediul virtual și ai instalat toate pachetele.

---

Pasul 2: Fă un screenshot

Computer Use funcționează prin analizarea screenshot-urilor. Codul tău capturează ecranul și îl convertește într-un șir de caractere codificat base64 pe care API-ul îl poate accepta.

Adaugă această funcție în 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")

Testează funcția adăugând o verificare rapidă la sfârșitul fișierului:

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

Acest lucru ar trebui să afișeze ceva de genul Screenshot captured: 2847392 characters (base64). Numărul exact depinde de rezoluția ecranului tău și de ceea ce se află pe ecran.

---

Pasul 3: Trimite un screenshot către GPT-5.4

Acum urmează nucleul Computer Use: trimiterea unui screenshot către GPT-5.4 cu instrumentul computer_use activat și primirea comenzilor de acțiune structurate în schimb.

Adaugă această funcție:

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

Parametrii cheie explicați:

• computer_use_preview — Îi spune lui GPT-5.4 să analizeze screenshot-ul și să returneze acțiuni desktop
• display_width / display_height — Rezoluția ecranului tău, astfel încât GPT-5.4 să returneze coordonate care se potrivesc cu afișajul tău real
• environment — Setat pe "mac", "windows", sau "linux" astfel încât GPT-5.4 să folosească scurtăturile de tastatură și convențiile UI corecte
• reasoning.effort — Controlează cât de mult raționament face GPT-5.4. Folosește "medium" pentru sarcini standard, "high" pentru fluxuri de lucru complexe cu mai mulți pași
• previous_response_id — Înlănțuie mai multe apeluri, astfel încât GPT-5.4 să-și amintească ce a făcut deja

---

Pasul 4: Execută acțiunile

GPT-5.4 returnează comenzi de acțiune structurate în răspunsul său. Trebuie să le analizezi și să le execuți cu PyAutoGUI.

Adaugă executorul de acțiuni:

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

Aceasta gestionează toate tipurile de acțiuni pe care GPT-5.4 le poate returna: clic, clic dublu, tastare, apăsări de taste, derulare și glisare.

---

Pasul 5: Construiește bucla de automatizare

Acum leagă totul într-o buclă completă de automatizare. Acesta este motorul principal care rulează sarcinile tale:

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

Acum poți rula orice sarcină de automatizare cu un singur apel de funcție:

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

Aceasta va captura ecranul tău, îl va trimite către GPT-5.4, iar GPT-5.4 va descoperi cum să deschidă Calculatorul și să efectueze înmulțirea — dând clic pe butoane, citind rezultatul și oprindu-se când a terminat.

---

Exemplu practic 1: Completarea automată a unui formular web

Iată un exemplu complet funcțional care completează un formular de contact web. Salvează-l ca 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()

Cum se utilizează:

1. Deschide o pagină web cu un formular de contact în browser-ul tău
2. Asigură-te că formularul este complet vizibil pe ecran (nu este necesară derularea pentru primele câmpuri)
3. Rulează python autofill_form.py
4. Urmărește cum GPT-5.4 identifică fiecare câmp, dă clic pe el și tastează valoarea corectă

---

Exemplu practic 2: Extragerea datelor dintr-o aplicație desktop

Acest exemplu citește date dintr-o foaie de calcul vizibilă sau dintr-o aplicație tabelară și le salvează într-un fișier CSV. Salvează-l ca 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()

Cum se utilizează:

1. Deschide o foaie de calcul, un vizualizator de baze de date sau orice aplicație cu date tabelare vizibile pe ecran
2. Rulează python extract_data.py
3. Verifică fișierul extracted_data.csv generat pentru conținutul extras

Pentru tabelele care se întind pe mai multe pagini, apelează în schimb extract_multi_page_data(). Acesta va derula automat și va combina toate paginile într-un singur CSV.

---

Cele mai bune practici de siguranță

Computer Use îi oferă lui GPT-5.4 capacitatea de a-ți controla mouse-ul și tastatura. Această putere necesită precauție.

Folosește întotdeauna un sandbox mai întâi. Înainte de a rula orice automatizare pe desktopul tău real, testează într-o mașină virtuală sau într-un container Docker cu un afișaj virtual. Acest lucru izolează greșelile și previne daunele accidentale.

Revizuiește acțiunile înainte de execuție. Modifică funcția execute_action pentru a afișa fiecare acțiune și a aștepta confirmarea ta înainte de a o executa:

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

Setează limite de rată. Adaugă un număr maxim de acțiuni pe sesiune și un buget maxim de cost. Parametrul max_steps din run_automation limitează deja numărul de bucle. De asemenea, poți urmări utilizarea token-urilor din obiectul de răspuns pentru a monitoriza costurile.

Nu automatiza niciodată conturi sensibile fără supraveghere. Nu îndrepta Computer Use către aplicația ta bancară, e-mailuri cu date sensibile sau console de administrare fără a urmări fiecare acțiune. GPT-5.4 poate da clic greșit, poate citi greșit elementele UI sau poate alege căi neintenționate.

Folosește mecanismul de siguranță al PyAutoGUI. Cu pyautogui.FAILSAFE = True (care este setarea implicită), poți anula orice automatizare mișcând rapid mouse-ul în colțul din stânga sus al ecranului. Păstrează acest lucru activat în orice moment.

---

Depanarea problemelor comune

"Modelul nu returnează nicio acțiune" -- Asigură-te că folosești computer_use_preview ca tip de instrument, nu doar computer_use. De asemenea, verifică dacă display_width și display_height corespund rezoluției tale reale a ecranului. Dacă valorile sunt greșite, GPT-5.4 s-ar putea să nu poată interpreta corect screenshot-ul.

"Click-urile ajung în poziția greșită" -- Acest lucru se întâmplă de obicei pe ecrane cu scalare (de exemplu, afișaje Retina pe macOS). PyAutoGUI lucrează în coordonate de pixeli, dar afișajul tău poate folosi coordonate logice. Încearcă să captezi rezoluția cu pyautogui.size() și compar-o cu rezoluția ta reală de pixeli. Pe macOS cu Retina, s-ar putea să fie necesar să împarți coordonatele la factorul tău de scalare.

"PyAutoGUI nu poate găsi afișajul" -- Pe servere Linux headless, instalează și pornește Xvfb: Xvfb :99 -screen 0 1920x1080x24 & apoi export DISPLAY=:99. Pe macOS, trebuie să acorzi permisiuni de accesibilitate pentru Terminal (sau IDE-ul tău) în System Settings > Privacy & Security > Accessibility.

"API returnează o eroare de limită de rată 429" -- Adaugă un time.sleep(2) între apelurile API sau implementează un exponential backoff. Sesiunile Computer Use GPT-5.4 pot atinge limitele de rată dacă trimiți screenshot-uri prea rapid.

"Costuri mari de token-uri" -- Screenshot-urile la rezoluție maximă consumă multe token-uri. Redu costurile prin redimensionarea screenshot-urilor înainte de a le codifica:

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

Când folosești screenshot-uri redimensionate, nu uita să înmulțești coordonatele returnate de GPT-5.4 cu inversul raportului înainte de a le trimite către PyAutoGUI.

"GPT-5.4 rămâne blocat într-o buclă" -- Dacă modelul continuă să repete aceeași acțiune, s-ar putea să fie confundat de starea UI. Adaugă logică pentru a detecta acțiunile repetate și a întrerupe bucla, sau mărește efortul de raționament la "high" pentru o mai bună luare a deciziilor.

---

Ce urmează

Odată ce ai bucla de automatizare de bază funcțională, iată modalități de a o extinde:

Înlănțuie mai multe sarcini. Construiește un flux de lucru care deschide e-mailul tău, descarcă o anexă, o deschide într-o foaie de calcul, extrage celule specifice și introduce valorile într-un șablon de raport. Fiecare pas folosește aceeași buclă screenshot-analiză-acțiune.

Adaugă recuperare din erori. Verifică fiecare screenshot pentru ferestre de eroare sau stări neașteptate. Dacă GPT-5.4 detectează că ceva nu a mers bine, poate încerca să recupereze dând clic pe "Cancel", apăsând Escape sau reîncercând ultima acțiune.

Combină cu Playwright pentru sarcini de browser. Pentru automatizarea exclusivă a web-ului, GPT-5.4 poate scrie, de asemenea, cod Playwright pentru a interacționa programatic cu browserele. Acest lucru este mai rapid și mai fiabil decât clicurile bazate pe screenshot-uri pentru pagini web structurate. Folosește Computer Use pentru aplicații desktop și Playwright pentru automatizarea browserului.

Construiește o bibliotecă de sarcini. Salvează prompt-urile și fluxurile de lucru comune ca funcții reutilizabile. Creează un director tasks/ cu scripturi precum fill_invoice.py, export_report.py și update_crm.py pe care echipa ta le poate rula la cerere.

Programează automatizările. Folosește cron (Linux/macOS) sau Task Scheduler (Windows) pentru a rula scripturile de automatizare la ore stabilite. Combină cu un afișaj virtual pentru o operare complet headless.

GPT-5.4 Computer Use este încă o capacitate nouă, iar suprafața API-ului va evolua. Păstrează pachetul openai actualizat cu pip install --upgrade openai pentru a obține cele mai recente tipuri de instrumente și parametri pe măsură ce OpenAI perfecționează funcția.

Codul din acest tutorial îți oferă o bază funcțională. Începe cu sarcini simple, cu risc scăzut, validează că automatizarea funcționează corect și apoi scalează către fluxuri de lucru mai complexe pe măsură ce capeți încredere în sistem.