Poin Penting

• Loop screenshot-tindakan adalah pola inti: Skrip Anda menangkap screenshot, mengirimkannya ke GPT-5.4 melalui Responses API dengan computer_use diaktifkan, menerima perintah tindakan terstruktur (klik, ketik, scroll), dan mengeksekusinya dengan PyAutoGUI dalam sebuah loop.
• GPT-5.4 mengalahkan pakar manusia di OSWorld sebesar 75%: Ini adalah model AI pertama yang melampaui performa manusia pada benchmark otomasi desktop, menjadikan otomasi praktis layak untuk alur kerja nyata.
• Biaya sangat rendah: Sesi otomasi tipikal dengan 10-20 screenshot menghabiskan biaya $0.10-0.50, ditagih sesuai tarif standar GPT-5.4 (sekitar $10/$30 per juta input/output tokens).
• Keamanan mengharuskan kode Anda untuk mengeksekusi tindakan: GPT-5.4 hanya mengirimkan perintah tindakan -- aplikasi Anda memutuskan apakah akan mengeksekusinya, membuat pengujian sandboxed dan peninjauan tindakan menjadi penting sebelum menjalankan tanpa pengawasan.
• Tiga prasyarat untuk memulai: Python 3.10+, sebuah OpenAI API key dengan akses Tier 1 (minimal pengeluaran sebelumnya $5), dan lingkungan desktop dengan layar.

GPT-5.4 mencetak skor 75% pada benchmark OSWorld, mengalahkan pakar manusia dalam otomasi desktop untuk pertama kalinya. Namun, mengetahui hasil benchmark dan benar-benar menggunakan Computer Use sendiri adalah dua hal yang sangat berbeda.

Panduan ini menjembatani kesenjangan tersebut. Pada akhirnya, Anda akan memiliki skrip Python yang berfungsi untuk menangkap screenshot desktop Anda, mengirimkannya ke GPT-5.4, menerima perintah tindakan terstruktur, dan mengeksekusinya secara otomatis. Tanpa teori, tanpa hype — hanya kode yang bisa Anda jalankan hari ini.

---

Apa yang Akan Anda Bangun

Anda akan membangun loop otomasi desktop lengkap yang bekerja seperti ini:

1. Skrip Anda menangkap screenshot layar Anda
2. Skrip tersebut mengirimkan screenshot tersebut ke GPT-5.4 melalui OpenAI Responses API dengan alat computer_use diaktifkan
3. GPT-5.4 menganalisis screenshot dan mengembalikan tindakan terstruktur (klik, ketik, scroll, penekanan tombol)
4. Skrip Anda mengeksekusi tindakan tersebut menggunakan PyAutoGUI
5. Loop berulang hingga tugas selesai

Pada akhir tutorial ini, Anda akan memiliki dua contoh yang berfungsi: satu yang mengisi formulir web secara otomatis, dan satu yang mengekstrak data dari aplikasi desktop ke dalam file CSV.

---

Prasyarat

Sebelum memulai, pastikan Anda memiliki hal-hal berikut:

• Python 3.10 atau versi terbaru terinstal di mesin Anda
• An OpenAI API key dengan akses ke GPT-5.4 (memerlukan akun berbayar dengan setidaknya akses Tier 1 — minimal pengeluaran sebelumnya $5)
• Lingkungan desktop — Computer Use berfungsi di macOS, Windows, dan Linux dengan layar. Untuk server headless, Anda memerlukan tampilan virtual seperti Xvfb
• Pengenalan dasar dengan Python (Anda tidak perlu menjadi ahli — semua kode disediakan)

---

Langkah 1: Siapkan Lingkungan Anda

Mulailah dengan membuat direktori proyek dan menginstal paket yang diperlukan.

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

Fungsi masing-masing paket:

• openai — OpenAI Python SDK resmi untuk memanggil GPT-5.4 API
• pyautogui — Library lintas platform untuk mengontrol mouse dan keyboard
• pillow — Library pemrosesan gambar untuk menangani screenshot

Selanjutnya, atur API key Anda sebagai variabel lingkungan:

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

Di Windows, gunakan set OPENAI_API_KEY=sk-your-api-key-here.

Buat file bernama automation.py dan tambahkan pengaturan dasar:

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

Jalankan ini untuk memverifikasi semuanya terinstal dengan benar:

python automation.py

Anda akan melihat resolusi layar Anda tercetak. Jika Anda mendapatkan kesalahan impor, periksa kembali apakah Anda telah mengaktifkan lingkungan virtual dan menginstal semua paket.

---

Langkah 2: Ambil Screenshot

Computer Use bekerja dengan menganalisis screenshot. Kode Anda menangkap layar dan mengubahnya menjadi string terenkode base64 yang dapat diterima oleh API.

Tambahkan fungsi ini ke 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")

Uji dengan menambahkan pemeriksaan cepat di bagian bawah file:

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

Ini akan mencetak sesuatu seperti Screenshot captured: 2847392 characters (base64). Angka pastinya tergantung pada resolusi layar Anda dan apa yang ada di layar.

---

Langkah 3: Kirim Screenshot ke GPT-5.4

Sekarang masuk ke inti dari Computer Use: mengirim screenshot ke GPT-5.4 dengan alat computer_use diaktifkan, dan menerima perintah tindakan terstruktur sebagai balasannya.

Tambahkan fungsi ini:

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

Penjelasan parameter kunci:

• computer_use_preview — Memberitahu GPT-5.4 untuk menganalisis screenshot dan mengembalikan tindakan desktop
• display_width / display_height — Resolusi layar Anda, sehingga GPT-5.4 mengembalikan koordinat yang sesuai dengan tampilan aktual Anda
• environment — Atur ke "mac", "windows", atau "linux" sehingga GPT-5.4 menggunakan pintasan keyboard dan konvensi UI yang tepat
• reasoning.effort — Mengontrol seberapa banyak penalaran yang dilakukan GPT-5.4. Gunakan "medium" untuk tugas standar, "high" untuk alur kerja multi-langkah yang kompleks
• previous_response_id — Menghubungkan beberapa panggilan bersama sehingga GPT-5.4 mengingat apa yang telah dilakukannya

---

Langkah 4: Eksekusi Tindakan

GPT-5.4 mengembalikan perintah tindakan terstruktur dalam responsnya. Anda perlu mengurai perintah ini dan mengeksekusinya dengan PyAutoGUI.

Tambahkan eksekutor tindakan:

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

Ini menangani semua jenis tindakan yang dapat dikembalikan oleh GPT-5.4: klik, klik dua kali, mengetik, penekanan tombol, scroll, dan seret.

---

Langkah 5: Bangun Loop Otomasi

Sekarang ikat semuanya menjadi loop otomasi yang lengkap. Ini adalah mesin utama yang menjalankan tugas Anda:

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

Sekarang Anda dapat menjalankan tugas otomasi apa pun dengan satu panggilan fungsi:

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

Ini akan menangkap layar Anda, mengirimkannya ke GPT-5.4, dan GPT-5.4 akan mencari tahu cara membuka Calculator dan melakukan perkalian — mengklik tombol, membaca hasil, dan berhenti setelah selesai.

---

Contoh Praktis 1: Isi Otomatis Formulir Web

Berikut adalah contoh lengkap yang mengisi formulir kontak web. Simpan ini sebagai 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()

Cara menggunakannya:

1. Buka halaman web dengan formulir kontak di browser Anda
2. Pastikan formulir terlihat sepenuhnya di layar (tidak perlu scroll untuk field pertama)
3. Jalankan python autofill_form.py
4. Lihat saat GPT-5.4 mengidentifikasi setiap field, mengkliknya, dan mengetikkan nilai yang benar

---

Contoh Praktis 2: Ekstrak Data dari Aplikasi Desktop

Contoh ini membaca data dari spreadsheet atau aplikasi tabel yang terlihat dan menyimpannya ke file CSV. Simpan ini sebagai 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()

Cara menggunakannya:

1. Buka spreadsheet, penampil database, atau aplikasi apa pun dengan data tabular yang terlihat di layar
2. Jalankan python extract_data.py
3. Periksa extracted_data.csv yang dihasilkan untuk konten yang diekstrak

Untuk tabel yang mencakup beberapa halaman, panggil extract_multi_page_data(). Ini akan secara otomatis melakukan scroll dan menggabungkan semua halaman ke dalam satu CSV.

---

Praktik Terbaik Keamanan

Computer Use memberikan GPT-5.4 kemampuan untuk mengontrol mouse dan keyboard Anda. Kekuatan itu membutuhkan kehati-hatian.

Selalu gunakan sandbox terlebih dahulu. Sebelum menjalankan otomasi apa pun di desktop asli Anda, uji di mesin virtual atau kontainer Docker dengan tampilan virtual. Ini mengisolasi kesalahan dan mencegah kerusakan yang tidak disengaja.

Tinjau tindakan sebelum eksekusi. Modifikasi fungsi execute_action untuk mencetak setiap tindakan dan menunggu konfirmasi Anda sebelum mengeksekusi:

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

Tetapkan batasan tarif. Tambahkan jumlah maksimum tindakan per sesi dan anggaran biaya maksimum. Parameter max_steps di run_automation sudah membatasi jumlah loop. Anda juga dapat melacak penggunaan token dari objek respons untuk memantau biaya.

Jangan pernah mengotomatiskan akun sensitif tanpa pengawasan. Jangan arahkan Computer Use ke aplikasi perbankan Anda, email dengan data sensitif, atau konsol admin tanpa mengawasi setiap tindakan. GPT-5.4 bisa salah klik, salah membaca elemen UI, atau mengambil jalur yang tidak diinginkan.

Gunakan fail-safe PyAutoGUI. Dengan pyautogui.FAILSAFE = True (yang merupakan default), Anda dapat membatalkan otomasi apa pun dengan menggerakkan mouse Anda dengan cepat ke sudut kiri atas layar. Biarkan ini tetap aktif setiap saat.

---

Pemecahan Masalah Umum

"Model tidak mengembalikan tindakan apa pun" -- Pastikan Anda menggunakan computer_use_preview sebagai jenis alat, bukan hanya computer_use. Verifikasi juga bahwa display_width dan display_height Anda sesuai dengan resolusi layar aktual Anda. Jika nilainya salah, GPT-5.4 mungkin tidak dapat menginterpretasikan screenshot dengan benar.

"Klik mendarat di posisi yang salah" -- Ini biasanya terjadi pada layar dengan penskalaan (misalnya, layar Retina di macOS). PyAutoGUI bekerja dalam koordinat piksel, tetapi layar Anda mungkin menggunakan koordinat logis. Coba tangkap resolusi Anda dengan pyautogui.size() dan bandingkan dengan resolusi piksel aktual Anda. Di macOS dengan Retina, Anda mungkin perlu membagi koordinat dengan faktor penskalaan Anda.

"PyAutoGUI tidak dapat menemukan layar" -- Pada server Linux headless, instal dan jalankan Xvfb: Xvfb :99 -screen 0 1920x1080x24 & lalu export DISPLAY=:99. Di macOS, Anda harus memberikan izin aksesibilitas ke Terminal (atau IDE Anda) di System Settings > Privacy & Security > Accessibility.

"API mengembalikan kesalahan batasan tarif 429" -- Tambahkan time.sleep(2) di antara panggilan API, atau terapkan exponential backoff. Sesi Computer Use GPT-5.4 dapat mencapai batas tarif jika Anda mengirim screenshot terlalu cepat.

"Biaya token tinggi" -- Screenshot pada resolusi penuh memakan banyak token. Kurangi biaya dengan mengubah ukuran screenshot sebelum mengenkodenya:

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

Saat menggunakan screenshot yang diubah ukurannya, ingatlah untuk mengalikan koordinat yang dikembalikan GPT-5.4 dengan kebalikan dari rasio tersebut sebelum meneruskannya ke PyAutoGUI.

"GPT-5.4 terjebak dalam loop" -- Jika model terus mengulangi tindakan yang sama, model mungkin bingung dengan status UI. Tambahkan logika untuk mendeteksi tindakan berulang dan menghentikan loop, atau tingkatkan penalaran ke "high" untuk pengambilan keputusan yang lebih baik.

---

Apa Selanjutnya

Setelah Anda berhasil menjalankan loop otomasi dasar, berikut adalah cara untuk mengembangkannya:

Rangkai beberapa tugas. Bangun alur kerja yang membuka email Anda, mengunduh lampiran, membukanya di spreadsheet, mengekstrak sel tertentu, dan menempelkan nilainya ke dalam templat laporan. Setiap langkah menggunakan loop screenshot-analisis-tindakan yang sama.

Tambahkan pemulihan kesalahan. Periksa setiap screenshot untuk dialog kesalahan atau status yang tidak terduga. Jika GPT-5.4 mendeteksi ada yang salah, ia dapat mencoba memulihkan diri dengan mengklik "Batal," menekan Escape, atau mencoba kembali tindakan terakhir.

Gabungkan dengan Playwright untuk tugas browser. Untuk otomasi khusus web, GPT-5.4 juga dapat menulis kode Playwright untuk berinteraksi dengan browser secara terprogram. Ini lebih cepat dan lebih andal daripada klik berbasis screenshot untuk halaman web terstruktur. Gunakan Computer Use untuk aplikasi desktop dan Playwright untuk otomasi browser.

Bangun perpustakaan tugas. Simpan prompt dan alur kerja umum sebagai fungsi yang dapat digunakan kembali. Buat direktori tasks/ dengan skrip seperti fill_invoice.py, export_report.py, dan update_crm.py yang dapat dijalankan tim Anda sesuai permintaan.

Jadwalkan otomasi. Gunakan cron (Linux/macOS) atau Task Scheduler (Windows) untuk menjalankan skrip otomasi Anda pada waktu yang ditentukan. Gabungkan dengan tampilan virtual untuk operasi headless sepenuhnya.

GPT-5.4 Computer Use masih merupakan kapabilitas baru, dan permukaan API akan terus berkembang. Jaga agar paket openai Anda tetap diperbarui dengan pip install --upgrade openai untuk mendapatkan jenis alat dan parameter terbaru saat OpenAI menyempurnakan fitur tersebut.

Kode dalam tutorial ini memberi Anda fondasi yang berfungsi. Mulailah dengan tugas-tugas sederhana yang berisiko rendah, validasi bahwa otomasi bekerja dengan benar, dan kemudian tingkatkan ke alur kerja yang lebih kompleks seiring Anda membangun kepercayaan pada sistem tersebut.